@certenza/aws-cdk-infrastructure-commons 2.3.1 → 2.4.0

package/dist/src/apigateway.d.ts

@@ -1,4 +1,7 @@
 import * as apigateway from "aws-cdk-lib/aws-apigateway";
+import * as apigatewayv2 from "aws-cdk-lib/aws-apigatewayv2";
+import * as lambda from "aws-cdk-lib/aws-lambda";
+import * as sqs from "aws-cdk-lib/aws-sqs";
 import { Construct } from "constructs";
 /**
  * Gets the domain name for the API Gateway
@@ -8,20 +11,34 @@ import { Construct } from "constructs";
  */
 declare const getApiGatewayDomainName: (service: string, domainName: string, environment: string) => string;
 /**
- * Creates an API Gateway with the given parameters
+ * Creates a REST API Gateway with the given parameters
  * @param scope - The scope of the API Gateway
  * @param apiName - The name of the API Gateway
  * @param domainName - The domain name of the API Gateway
  * @param hostedZoneId - The ID of the hosted zone
  * @param zoneName - The name of the hosted zone
- * @returns The API Gateway
+ * @returns The REST API Gateway
  */
 declare const createApiGateway: (scope: Construct, apiName: string, domainName: string, hostedZoneId: string, zoneName: string) => apigateway.RestApi;
 /**
- * Imports an API Gateway from the given stack name
+ * Creates an HTTP API Gateway with the given parameters
  * @param scope - The scope of the API Gateway
- * @param apiName - The name of the API Gateway to import
- * @returns The imported API Gateway
+ * @param apiName - The name of the API Gateway
+ * @param domainName - The domain name of the API Gateway
+ * @param hostedZoneId - The ID of the hosted zone
+ * @param zoneName - The name of the hosted zone
+ * @param defaultAuthorizer - The default authorizer for the API Gateway (default is an IAM authorizer)
+ * @returns The HTTP API Gateway
+ */
+declare const createHttpApiGateway: (scope: Construct, apiName: string, domainName: string, hostedZoneId: string, zoneName: string, defaultAuthorizer?: apigatewayv2.IHttpRouteAuthorizer) => apigatewayv2.HttpApi;
+declare const createHttpApiGatewayLambdaEndpoint: (method: "POST" | "GET" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD", path: string, lambdaFunction: lambda.IFunction, api: apigatewayv2.HttpApi) => apigatewayv2.IHttpRoute[];
+/**
+ * Creates an HTTP API Gateway SQS endpoint
+ * @param method - The HTTP method for the endpoint (POST, GET, PUT, DELETE, PATCH, OPTIONS, HEAD)
+ * @param path - The path for the endpoint (e.g., "/messages")
+ * @param queue - The SQS queue to integrate with
+ * @param api - The HTTP API Gateway to add the endpoint to
+ * @returns The route configuration
  */
-declare const importApiGateway: (scope: Construct, apiName: string) => apigateway.IRestApi;
-export { createApiGateway, getApiGatewayDomainName, importApiGateway };
+declare const createHttpApiGatewaySQSEndpoint: (method: "POST" | "GET" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD", path: string, queue: sqs.IQueue, api: apigatewayv2.HttpApi) => apigatewayv2.IHttpRoute[];
+export { createApiGateway, createHttpApiGateway, createHttpApiGatewayLambdaEndpoint, createHttpApiGatewaySQSEndpoint, getApiGatewayDomainName, };

package/dist/src/apigateway.js

@@ -33,15 +33,18 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.importApiGateway = exports.getApiGatewayDomainName = exports.createApiGateway = void 0;
+exports.getApiGatewayDomainName = exports.createHttpApiGatewaySQSEndpoint = exports.createHttpApiGatewayLambdaEndpoint = exports.createHttpApiGateway = exports.createApiGateway = void 0;
 const apigateway = __importStar(require("aws-cdk-lib/aws-apigateway"));
+const apigatewayv2 = __importStar(require("aws-cdk-lib/aws-apigatewayv2"));
+const apigatewayv2_integrations = __importStar(require("aws-cdk-lib/aws-apigatewayv2-integrations"));
 const logs = __importStar(require("aws-cdk-lib/aws-logs"));
 const route53 = __importStar(require("aws-cdk-lib/aws-route53"));
 const route53targets = __importStar(require("aws-cdk-lib/aws-route53-targets"));
+const aws_apigatewayv2_authorizers_1 = require("aws-cdk-lib/aws-apigatewayv2-authorizers");
+const iam = __importStar(require("aws-cdk-lib/aws-iam"));
 const cdk = __importStar(require("aws-cdk-lib"));
 const acm_1 = require("./acm");
 const route53_1 = require("./route53");
-const aws_cdk_lib_1 = require("aws-cdk-lib");
 /**
  * Gets the domain name for the API Gateway
  * @param environment - The environment to get the domain name for
@@ -55,13 +58,13 @@ const getApiGatewayDomainName = (service, domainName, environment) => {
 };
 exports.getApiGatewayDomainName = getApiGatewayDomainName;
 /**
- * Creates an API Gateway with the given parameters
+ * Creates a REST API Gateway with the given parameters
  * @param scope - The scope of the API Gateway
  * @param apiName - The name of the API Gateway
  * @param domainName - The domain name of the API Gateway
  * @param hostedZoneId - The ID of the hosted zone
  * @param zoneName - The name of the hosted zone
- * @returns The API Gateway
+ * @returns The REST API Gateway
  */
 const createApiGateway = (scope, apiName, domainName, hostedZoneId, zoneName) => {
     // Import the existing hosted zone
@@ -93,36 +96,99 @@ const createApiGateway = (scope, apiName, domainName, hostedZoneId, zoneName) =>
         recordName: domainName.replace(`${hostedZone.zoneName}.`, ""),
         target: route53.RecordTarget.fromAlias(new route53targets.ApiGateway(api)),
     });
-    // Add a dummy endpoint to prevent API Gateway deployment errors
-    // when the API has only one endpoint. This ensures the API can be deployed
-    // even if no other methods are added yet.
-    api.root.addMethod("GET", new apigateway.MockIntegration({
-        requestTemplates: {
-            "application/json": '{"statusCode": 200}',
-        },
-        integrationResponses: [
-            {
-                statusCode: "200",
-                responseTemplates: {
-                    "application/json": "",
-                },
-            },
-        ],
-    }));
     // Return the API Gateway
     return api;
 };
 exports.createApiGateway = createApiGateway;
 /**
- * Imports an API Gateway from the given stack name
+ * Creates an HTTP API Gateway with the given parameters
  * @param scope - The scope of the API Gateway
- * @param apiName - The name of the API Gateway to import
- * @returns The imported API Gateway
+ * @param apiName - The name of the API Gateway
+ * @param domainName - The domain name of the API Gateway
+ * @param hostedZoneId - The ID of the hosted zone
+ * @param zoneName - The name of the hosted zone
+ * @param defaultAuthorizer - The default authorizer for the API Gateway (default is an IAM authorizer)
+ * @returns The HTTP API Gateway
+ */
+const createHttpApiGateway = (scope, apiName, domainName, hostedZoneId, zoneName, defaultAuthorizer) => {
+    // Import the existing hosted zone
+    const hostedZone = (0, route53_1.getHostedZone)(scope, "HostedZone", hostedZoneId, zoneName);
+    // Create a certificate for the API Gateway domain
+    const certificate = (0, acm_1.createCertificate)(scope, `HttpApiGatewayCertificate`, domainName, hostedZone);
+    // Create the domain name for the HTTP API
+    const apiDomainName = new apigatewayv2.DomainName(scope, `${apiName}-Domain`, {
+        domainName: domainName,
+        certificate: certificate,
+        securityPolicy: apigatewayv2.SecurityPolicy.TLS_1_2,
+    });
+    // Create the HTTP API Gateway
+    const api = new apigatewayv2.HttpApi(scope, apiName, {
+        description: `Public HTTP API Gateway for ${apiName}`,
+        defaultDomainMapping: {
+            domainName: apiDomainName,
+        },
+        defaultAuthorizer: defaultAuthorizer ?? new aws_apigatewayv2_authorizers_1.HttpIamAuthorizer(),
+    });
+    // Create Route53 A record pointing to the API Gateway domain
+    new route53.ARecord(scope, `${apiName}-AliasRecord`, {
+        zone: hostedZone,
+        recordName: domainName.replace(`${hostedZone.zoneName}.`, ""),
+        target: route53.RecordTarget.fromAlias(new route53targets.ApiGatewayv2DomainProperties(apiDomainName.regionalDomainName, apiDomainName.regionalHostedZoneId)),
+    });
+    // Return the HTTP API Gateway
+    return api;
+};
+exports.createHttpApiGateway = createHttpApiGateway;
+/**
+ * Gets the HTTP method for the given method
+ * @param method - The method to get the HTTP method for (POST, GET, PUT, DELETE, PATCH, OPTIONS, HEAD)
+ * @returns The HTTP method
+ */
+const getHttpMethod = (method) => {
+    switch (method) {
+        case "POST":
+            return apigatewayv2.HttpMethod.POST;
+        case "GET":
+            return apigatewayv2.HttpMethod.GET;
+        case "PUT":
+            return apigatewayv2.HttpMethod.PUT;
+        case "DELETE":
+            return apigatewayv2.HttpMethod.DELETE;
+        case "PATCH":
+            return apigatewayv2.HttpMethod.PATCH;
+        case "OPTIONS":
+            return apigatewayv2.HttpMethod.OPTIONS;
+        default:
+            return apigatewayv2.HttpMethod.HEAD;
+    }
+};
+const createHttpApiGatewayLambdaEndpoint = (method, path, lambdaFunction, api) => {
+    return api.addRoutes({
+        path: path,
+        methods: [getHttpMethod(method)],
+        integration: new apigatewayv2_integrations.HttpLambdaIntegration(lambdaFunction.functionName, lambdaFunction),
+    });
+};
+exports.createHttpApiGatewayLambdaEndpoint = createHttpApiGatewayLambdaEndpoint;
+/**
+ * Creates an HTTP API Gateway SQS endpoint
+ * @param method - The HTTP method for the endpoint (POST, GET, PUT, DELETE, PATCH, OPTIONS, HEAD)
+ * @param path - The path for the endpoint (e.g., "/messages")
+ * @param queue - The SQS queue to integrate with
+ * @param api - The HTTP API Gateway to add the endpoint to
+ * @returns The route configuration
  */
-const importApiGateway = (scope, apiName) => {
-    return apigateway.RestApi.fromRestApiAttributes(scope, `Imported-${apiName}-Api`, {
-        restApiId: aws_cdk_lib_1.Fn.importValue(`CertenzaInfrastructureApiGatewayStack-${apiName}Id`),
-        rootResourceId: aws_cdk_lib_1.Fn.importValue(`CertenzaInfrastructureApiGatewayStack-${apiName}RootResourceId`),
+const createHttpApiGatewaySQSEndpoint = (method, path, queue, api) => {
+    // Grant API Gateway service permission to send messages to SQS
+    // This matches the behavior of createSQSApiGatewayIntegration
+    // For HTTP API Gateway v2, we grant permissions directly to the service principal
+    queue.grantSendMessages(new iam.ServicePrincipal("apigateway.amazonaws.com"));
+    return api.addRoutes({
+        path: path,
+        methods: [getHttpMethod(method)],
+        integration: new apigatewayv2_integrations.HttpSqsIntegration(queue.queueName, {
+            queue: queue,
+        }),
     });
 };
-exports.importApiGateway = importApiGateway;
+exports.createHttpApiGatewaySQSEndpoint = createHttpApiGatewaySQSEndpoint;

package/dist/src/lambda.d.ts

@@ -26,7 +26,7 @@ type CreateLambdaFunctionProps = {
  */
 declare const createLambdaFunction: (scope: Construct, functionName: string, environment: string, props?: CreateLambdaFunctionProps) => nodejs.NodejsFunction;
 /**
- * Creates a lambda integration for a lambda function
+ * Creates a lambda integration for a REST API Gateway
  * @param lambdaFunction - The lambda function to create an integration for
  * @returns The lambda integration
  */

package/dist/src/lambda.js

@@ -102,7 +102,7 @@ const createLambdaFunction = (scope, functionName, environment, props = {}) => {
 };
 exports.createLambdaFunction = createLambdaFunction;
 /**
- * Creates a lambda integration for a lambda function
+ * Creates a lambda integration for a REST API Gateway
  * @param lambdaFunction - The lambda function to create an integration for
  * @returns The lambda integration
  */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@certenza/aws-cdk-infrastructure-commons",
-    "version": "2.3.1",
+    "version": "2.4.0",
     "description": "Common infrastructure reusable utilities and resources for Certenza projects",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",