@incloodsolutions/devkit 0.0.4 → 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';
@@ -542,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
        */
@@ -685,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");
@@ -881,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