@incloodsolutions/devkit 0.0.3 → 0.0.5

package/dist/index.js

@@ -1,9 +1,9 @@
 import { Construct } from 'constructs';
-import { Size, RemovalPolicy, CfnOutput, Duration } from 'aws-cdk-lib';
+import { Size, RemovalPolicy, CfnOutput, Duration, Stack } from 'aws-cdk-lib';
 import { RestApi, Cors, LambdaIntegration, TokenAuthorizer } from 'aws-cdk-lib/aws-apigateway';
 import { printLog, CustomException, detectDuplicateProperties, AppEnvironmentEnum } from '@incloodsolutions/toolkit';
 import { HttpLambdaIntegration, WebSocketLambdaIntegration } from 'aws-cdk-lib/aws-apigatewayv2-integrations';
-import { HttpApi, CorsHttpMethod, WebSocketApi, WebSocketStage } from 'aws-cdk-lib/aws-apigatewayv2';
+import { HttpApi, CorsHttpMethod, WebSocketApi, WebSocketStage, HttpMethod } from 'aws-cdk-lib/aws-apigatewayv2';
 import { Distribution, ViewerProtocolPolicy } from 'aws-cdk-lib/aws-cloudfront';
 import { LogGroup, RetentionDays } from 'aws-cdk-lib/aws-logs';
 import { Table, BillingMode } from 'aws-cdk-lib/aws-dynamodb';
@@ -12,6 +12,7 @@ import { LambdaFunction } from 'aws-cdk-lib/aws-events-targets';
 import { HttpLambdaAuthorizer, HttpLambdaResponseType } from 'aws-cdk-lib/aws-apigatewayv2-authorizers';
 import { Function, Architecture, Runtime, Code, LayerVersion, EventSourceMapping } from 'aws-cdk-lib/aws-lambda';
 import { Role, ManagedPolicy, PolicyStatement } from 'aws-cdk-lib/aws-iam';
+import { HostedZone, ARecord, AaaaRecord, CnameRecord, TxtRecord } from 'aws-cdk-lib/aws-route53';
 import { Bucket } from 'aws-cdk-lib/aws-s3';
 import { S3BucketOrigin } from 'aws-cdk-lib/aws-cloudfront-origins';
 import { BucketDeployment } from 'aws-cdk-lib/aws-s3-deployment';
@@ -99,7 +100,10 @@ var BaseApiGatewayConstruct = class _BaseApiGatewayConstruct extends Construct {
         this.addRoutes(resource, route.children, integration, currentPath);
       }
       if (this.enableDebug) {
-        printLog(_BaseApiGatewayConstruct.name, `Route created: ${route.method} ${currentPath}`);
+        printLog(
+          _BaseApiGatewayConstruct.name,
+          `Route created: ${route.method} ${currentPath}`
+        );
       }
     });
   }
@@ -187,27 +191,39 @@ var BaseApiGatewayWebSocketConstruct = class extends Construct {
        */
       connectRouteOptions: {
         ...props.handlers.connect?.option,
-        integration: new WebSocketLambdaIntegration("connectIntegration", props.handlers.connect.function)
+        integration: new WebSocketLambdaIntegration(
+          "connectIntegration",
+          props.handlers.connect.function
+        )
       },
       /**
        * Route for disconnection events ($disconnect)
        */
       disconnectRouteOptions: {
         ...props.handlers.disconnect?.option,
-        integration: new WebSocketLambdaIntegration("disconnectIntegration", props.handlers.disconnect.function)
+        integration: new WebSocketLambdaIntegration(
+          "disconnectIntegration",
+          props.handlers.disconnect.function
+        )
       },
       /**
        * Default route for unmatched messages ($default)
        */
       defaultRouteOptions: {
         ...props.handlers.default?.option,
-        integration: new WebSocketLambdaIntegration("defaultIntegration", props.handlers.default.function)
+        integration: new WebSocketLambdaIntegration(
+          "defaultIntegration",
+          props.handlers.default.function
+        )
       }
     });
     this.socketApi.addRoute("notifications", {
       ...props.handlers.message?.option,
       /** Lambda integration for message handling */
-      integration: new WebSocketLambdaIntegration("routes", props.handlers.message.function)
+      integration: new WebSocketLambdaIntegration(
+        "routes",
+        props.handlers.message.function
+      )
     });
     const webSocketStage = new WebSocketStage(this, `${id}_stage`, {
       ...props.options?.webSocketStageOptions,
@@ -493,7 +509,10 @@ var BaseLambdaAuthoriserV2Construct = class extends Construct {
        * Supported response types for the authorizer
        * Defaults to IAM and SIMPLE responses
        */
-      responseTypes: props?.options?.authorizerOptions?.responseTypes || [HttpLambdaResponseType.IAM, HttpLambdaResponseType.SIMPLE]
+      responseTypes: props?.options?.authorizerOptions?.responseTypes || [
+        HttpLambdaResponseType.IAM,
+        HttpLambdaResponseType.SIMPLE
+      ]
     });
     new CfnOutput(this, "LambdaAuthorizerV2_ID", {
       value: this.authoriser.authorizerId
@@ -524,9 +543,9 @@ var BaseLambdaConstruct = class extends Construct {
       ...props?.options?.lambdaOptions,
       /**
        * Lambda function name
-       * Defaults to "<stackName>-handler" if not provided
+       * Defaults to "<stackName>" if not provided
        */
-      functionName: `${props?.options?.lambdaOptions?.functionName || props?.stackName}-handler`,
+      functionName: `${props?.options?.lambdaOptions?.functionName || props?.stackName}`,
       /**
        * Function description
        */
@@ -610,10 +629,7 @@ var BaseLambdaLayerConstruct = class extends Construct {
         /**
          * Supported CPU architectures
          */
-        compatibleArchitectures: [
-          Architecture.ARM_64,
-          Architecture.X86_64
-        ],
+        compatibleArchitectures: [Architecture.ARM_64, Architecture.X86_64],
         /**
          * Supported runtimes
          */
@@ -670,6 +686,72 @@ var BaseRolePolicyConstruct = class extends Construct {
     });
   }
 };
+var BaseRoute53Construct = class extends Construct {
+  static {
+    __name(this, "BaseRoute53Construct");
+  }
+  /** The hosted zone this construct created, imported, or looked up */
+  hostedZone;
+  /**
+   * @param scope Parent construct
+   * @param id Unique construct identifier
+   * @param props Configuration for the hosted zone and its records
+   */
+  constructor(scope, id, props) {
+    super(scope, id);
+    const options = props?.options ?? {};
+    if (options.hostedZoneOptions) {
+      this.hostedZone = new HostedZone(
+        this,
+        `${id}-HostedZone`,
+        options.hostedZoneOptions
+      );
+    } else if (options.fromExistingHostedZoneAttributes) {
+      this.hostedZone = HostedZone.fromHostedZoneAttributes(
+        this,
+        `${id}-HostedZone`,
+        options.fromExistingHostedZoneAttributes
+      );
+    } else if (options.fromLookupOptions) {
+      this.hostedZone = HostedZone.fromLookup(
+        this,
+        `${id}-HostedZone`,
+        options.fromLookupOptions
+      );
+    } else {
+      throw new CustomException(
+        "BaseRoute53Construct requires one of hostedZoneOptions, fromExistingHostedZoneAttributes, or fromLookupOptions"
+      );
+    }
+    options.aRecords?.forEach((record, index) => {
+      new ARecord(this, `${id}-ARecord-${index}`, {
+        ...record,
+        zone: this.hostedZone
+      });
+    });
+    options.aaaaRecords?.forEach((record, index) => {
+      new AaaaRecord(this, `${id}-AaaaRecord-${index}`, {
+        ...record,
+        zone: this.hostedZone
+      });
+    });
+    options.cnameRecords?.forEach((record, index) => {
+      new CnameRecord(this, `${id}-CnameRecord-${index}`, {
+        ...record,
+        zone: this.hostedZone
+      });
+    });
+    options.txtRecords?.forEach((record, index) => {
+      new TxtRecord(this, `${id}-TxtRecord-${index}`, {
+        ...record,
+        zone: this.hostedZone
+      });
+    });
+    new CfnOutput(this, "Route53HostedZoneId", {
+      value: this.hostedZone.hostedZoneId
+    });
+  }
+};
 var BaseS3Construct = class extends Construct {
   static {
     __name(this, "BaseS3Construct");
@@ -714,10 +796,14 @@ var BaseS3DeploymentConstruct = class extends Construct {
   constructor(scope, id, props) {
     super(scope, id);
     if (!props.options?.cloudfrontOptions?.defaultBehavior?.origin && !props?.withS3Bucket && props.withCloudfront) {
-      throw new CustomException("Cloudfront distribution S3_Bucket origins must be defined!");
+      throw new CustomException(
+        "Cloudfront distribution S3_Bucket origins must be defined!"
+      );
     }
     if (!props.options?.bucketDeploymentOptions?.destinationBucket && !props?.withS3Bucket) {
-      throw new CustomException("Deployment S3_Bucket destination must be defined!");
+      throw new CustomException(
+        "Deployment S3_Bucket destination must be defined!"
+      );
     }
     if (props?.withS3Bucket) {
       this.bucket = new BaseS3Construct(this, "bucket", {
@@ -735,13 +821,18 @@ var BaseS3DeploymentConstruct = class extends Construct {
             /**
              * Map additional behaviors and ensure origin is assigned
              */
-            additionalBehaviors: Object.entries(props.options?.cloudfrontOptions?.additionalBehaviors || {}).reduce((behavior, [pattern, behaviorOptions]) => {
-              behavior[pattern] = {
-                ...behaviorOptions,
-                origin: behaviorOptions.origin || s3Origin
-              };
-              return behavior;
-            }, {}),
+            additionalBehaviors: Object.entries(
+              props.options?.cloudfrontOptions?.additionalBehaviors || {}
+            ).reduce(
+              (behavior, [pattern, behaviorOptions]) => {
+                behavior[pattern] = {
+                  ...behaviorOptions,
+                  origin: behaviorOptions.origin || s3Origin
+                };
+                return behavior;
+              },
+              {}
+            ),
             /**
              * Default behavior configuration
              */
@@ -857,7 +948,133 @@ var BaseVpcConstruct = class extends Construct {
     });
   }
 };
+var BaseLambdaApiStack = class extends Stack {
+  static {
+    __name(this, "BaseLambdaApiStack");
+  }
+  constructor(scope, id, props) {
+    super(scope, id, props);
+    let layers = [];
+    if (props?.stackOptions?.layerOptions) {
+      if (!props.stackOptions?.layerOptions?.name || !props.stackOptions?.layerOptions?.version) {
+        throw new CustomException("Invalid layer options provided! Both layer 'name' and 'version' are required.");
+      }
+      const { existingLayer } = new BaseLambdaLayerConstruct(
+        this,
+        "layer",
+        {
+          options: {
+            fromExistingLayerArn: `arn:aws:lambda:${props.env?.region}:${props.env?.account}:layer:${props.stackOptions?.layerOptions?.name}:${props.stackOptions?.layerOptions?.version}`
+          }
+        }
+      );
+      layers.push(existingLayer);
+    }
+    const { function: lambdaFunction } = new BaseLambdaConstruct(this, "lambda", {
+      stage: props.stackOptions?.stage,
+      stackName: props.stackName,
+      options: {
+        lambdaOptions: { layers }
+      }
+    });
+    new BaseApiGatewayV2Construct(this, "apiGateway", {
+      handlerFunctions: [lambdaFunction],
+      options: {
+        gatewayOptions: {
+          apiName: props.stackName,
+          corsPreflight: {
+            allowOrigins: ["*"]
+          }
+        },
+        routeOptions: [
+          {
+            path: "/{proxy+}",
+            methods: [HttpMethod.ANY]
+          }
+        ]
+      }
+    });
+  }
+};
+var BaseLambdaSqsStack = class extends Stack {
+  static {
+    __name(this, "BaseLambdaSqsStack");
+  }
+  constructor(scope, id, props) {
+    super(scope, id, props);
+    let layers = [];
+    if (props?.stackOptions?.layerOptions) {
+      if (!props.stackOptions?.layerOptions?.name || !props.stackOptions?.layerOptions?.version) {
+        throw new CustomException("Invalid layer options provided");
+      }
+      const { existingLayer } = new BaseLambdaLayerConstruct(
+        this,
+        "layer",
+        {
+          options: {
+            fromExistingLayerArn: `arn:aws:lambda:${props.env?.region}:${props.env?.account}:layer:${props.stackOptions?.layerOptions?.name}:${props.stackOptions?.layerOptions?.version}`
+          }
+        }
+      );
+      layers.push(existingLayer);
+    }
+    const { function: lambdaFunction } = new BaseLambdaConstruct(this, "lambda", {
+      stage: props.stackOptions?.stage,
+      stackName: props.stackName,
+      options: {
+        lambdaOptions: { layers }
+      }
+    });
+    new BaseSqsConstruct(this, "sqs", {
+      targetFunctions: [lambdaFunction],
+      options: {
+        eventSourceMappingOptions: {},
+        queueOptions: {}
+      }
+    });
+  }
+};
+var BaseLambdaSnsStack = class extends Stack {
+  static {
+    __name(this, "BaseLambdaSnsStack");
+  }
+  constructor(scope, id, props) {
+    super(scope, id, props);
+    let layers = [];
+    if (props?.stackOptions?.layerOptions) {
+      if (!props.stackOptions?.layerOptions?.name || !props.stackOptions?.layerOptions?.version) {
+        throw new CustomException("Invalid layer options provided");
+      }
+      const { existingLayer } = new BaseLambdaLayerConstruct(
+        this,
+        "layer",
+        {
+          options: {
+            fromExistingLayerArn: `arn:aws:lambda:${props.env?.region}:${props.env?.account}:layer:${props.stackOptions?.layerOptions?.name}:${props.stackOptions?.layerOptions?.version}`
+          }
+        }
+      );
+      layers.push(existingLayer);
+    }
+    const { function: lambdaFunction } = new BaseLambdaConstruct(this, "lambda", {
+      stage: props.stackOptions?.stage,
+      stackName: props.stackName,
+      options: {
+        lambdaOptions: { layers }
+      }
+    });
+    new BaseSnsConstruct(this, "sns", {
+      options: {
+        targetFunctions: [lambdaFunction],
+        topicOptions: {
+          ...props?.stackOptions?.topicOptions,
+          topicName: props?.stackOptions?.topicOptions?.topicName || props.stackName
+        }
+      }
+    });
+  }
+};
 
-export { BaseApiGatewayConstruct, BaseApiGatewayV2Construct, BaseApiGatewayWebSocketConstruct, BaseCloudfrontConstruct, BaseCloudwatchLogGroupConstruct, BaseDynamoDBConstruct, BaseEventBridgeConstruct, BaseLambdaAuthoriserConstruct, BaseLambdaAuthoriserV2Construct, BaseLambdaConstruct, BaseLambdaLayerConstruct, BaseRolePolicyConstruct, BaseS3Construct, BaseS3DeploymentConstruct, BaseSnsConstruct, BaseSqsConstruct, BaseVpcConstruct };
+export { BaseApiGatewayConstruct, BaseApiGatewayV2Construct, BaseApiGatewayWebSocketConstruct, BaseCloudfrontConstruct, BaseCloudwatchLogGroupConstruct, BaseDynamoDBConstruct, BaseEventBridgeConstruct, BaseLambdaApiStack, BaseLambdaAuthoriserConstruct, BaseLambdaAuthoriserV2Construct, BaseLambdaConstruct, BaseLambdaLayerConstruct, BaseLambdaSnsStack, BaseLambdaSqsStack, BaseRolePolicyConstruct, BaseRoute53Construct, BaseS3Construct, BaseS3DeploymentConstruct, BaseSnsConstruct, BaseSqsConstruct, BaseVpcConstruct };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map