@incloodsolutions/devkit 0.0.1 → 0.0.3

package/dist/aws/cdk/index.cjs

@@ -0,0 +1,881 @@
+'use strict';
+
+var constructs = require('constructs');
+var awsCdkLib = require('aws-cdk-lib');
+var awsApigateway = require('aws-cdk-lib/aws-apigateway');
+var toolkit = require('@incloodsolutions/toolkit');
+var awsApigatewayv2Integrations = require('aws-cdk-lib/aws-apigatewayv2-integrations');
+var awsApigatewayv2 = require('aws-cdk-lib/aws-apigatewayv2');
+var awsCloudfront = require('aws-cdk-lib/aws-cloudfront');
+var awsLogs = require('aws-cdk-lib/aws-logs');
+var awsDynamodb = require('aws-cdk-lib/aws-dynamodb');
+var awsEvents = require('aws-cdk-lib/aws-events');
+var awsEventsTargets = require('aws-cdk-lib/aws-events-targets');
+var awsApigatewayv2Authorizers = require('aws-cdk-lib/aws-apigatewayv2-authorizers');
+var awsLambda = require('aws-cdk-lib/aws-lambda');
+var awsIam = require('aws-cdk-lib/aws-iam');
+var awsS3 = require('aws-cdk-lib/aws-s3');
+var awsCloudfrontOrigins = require('aws-cdk-lib/aws-cloudfront-origins');
+var awsS3Deployment = require('aws-cdk-lib/aws-s3-deployment');
+var awsSns = require('aws-cdk-lib/aws-sns');
+var awsSnsSubscriptions = require('aws-cdk-lib/aws-sns-subscriptions');
+var awsSqs = require('aws-cdk-lib/aws-sqs');
+var awsEc2 = require('aws-cdk-lib/aws-ec2');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var BaseApiGatewayConstruct = class _BaseApiGatewayConstruct extends constructs.Construct {
+  static {
+    __name(this, "BaseApiGatewayConstruct");
+  }
+  /** The created REST API instance */
+  api;
+  /** Enables debug logging for route creation */
+  enableDebug = false;
+  /**
+   * @param scope Parent construct
+   * @param id Unique construct identifier
+   * @param props Configuration for API, routes, and Lambda handler
+   */
+  constructor(scope, id, props) {
+    super(scope, id);
+    this.enableDebug = props.enableDebug;
+    this.api = new awsApigateway.RestApi(this, id, {
+      ...props?.options?.gatewayOptions,
+      /** Default API description if not provided */
+      description: props?.options?.gatewayOptions?.description || "This is a REST API using CDK",
+      /**
+       * CORS configuration
+       * Falls back to allowing all origins, methods, and standard headers
+       */
+      defaultCorsPreflightOptions: {
+        ...props?.options?.gatewayOptions?.defaultCorsPreflightOptions,
+        /** Allow all origins by default */
+        allowOrigins: props?.options?.gatewayOptions?.defaultCorsPreflightOptions?.allowOrigins || awsApigateway.Cors.ALL_ORIGINS,
+        /** Allow all HTTP methods by default */
+        allowMethods: props?.options?.gatewayOptions?.defaultCorsPreflightOptions?.allowMethods || awsApigateway.Cors.ALL_METHODS,
+        /** Merge default headers with user-defined headers */
+        allowHeaders: [
+          ...props.options?.gatewayOptions?.defaultCorsPreflightOptions?.allowHeaders,
+          "Content-Type",
+          "Accept",
+          "X-Amz-Date",
+          "Authorization",
+          "X-Api-Key",
+          "X-Amz-Security-Token",
+          "X-Amz-User-Agent"
+        ]
+      },
+      /** Minimum payload size (in bytes) before compression is applied */
+      minCompressionSize: props?.options?.gatewayOptions?.minCompressionSize || awsCdkLib.Size.bytes(1)
+    });
+    if (props?.options?.routeOptions?.length && props?.handlerFunction) {
+      const integration = new awsApigateway.LambdaIntegration(props.handlerFunction);
+      this.addRoutes(this.api.root, props.options.routeOptions, integration);
+    }
+    this.api.applyRemovalPolicy(awsCdkLib.RemovalPolicy.DESTROY);
+    new awsCdkLib.CfnOutput(this, "ApiGateway", {
+      value: this.api.url
+    });
+  }
+  /**
+   * Recursively attaches routes to the API Gateway
+   *
+   * Behaviour:
+   * - Creates a resource for each route segment
+   * - Attaches method + Lambda integration
+   * - Traverses child routes for nested paths
+   *
+   * @param parent Parent API resource
+   * @param routes Route definitions
+   * @param integration Lambda integration applied to each route
+   * @param previousPath Accumulated path (used for debug logging)
+   * @private
+   */
+  addRoutes(parent, routes, integration, previousPath) {
+    routes.forEach((route) => {
+      const currentPath = `${previousPath || ""}/${route.name}`;
+      const resource = parent.addResource(route.name);
+      resource.addMethod(route.method, integration);
+      if (route?.children.length) {
+        this.addRoutes(resource, route.children, integration, currentPath);
+      }
+      if (this.enableDebug) {
+        toolkit.printLog(_BaseApiGatewayConstruct.name, `Route created: ${route.method} ${currentPath}`);
+      }
+    });
+  }
+};
+var BaseApiGatewayV2Construct = class extends constructs.Construct {
+  static {
+    __name(this, "BaseApiGatewayV2Construct");
+  }
+  /** The created HTTP API instance */
+  api;
+  /** Enables debug logging (if used externally) */
+  enableDebug = false;
+  /**
+   * @param scope Parent construct
+   * @param id Unique construct identifier
+   * @param props Configuration for API, routes, and handlers
+   */
+  constructor(scope, id, props) {
+    super(scope, id);
+    this.enableDebug = props.enableDebug;
+    this.api = new awsApigatewayv2.HttpApi(this, id, {
+      ...props?.options?.gatewayOptions,
+      /** Default API description if not provided */
+      description: props?.options?.gatewayOptions?.description || "This is an Http API using CDK",
+      /**
+       * CORS configuration
+       * Falls back to allowing all methods and standard headers if not explicitly defined
+       */
+      corsPreflight: {
+        ...props.options?.gatewayOptions?.corsPreflight,
+        /** Allow all HTTP methods by default */
+        allowMethods: props.options?.gatewayOptions?.corsPreflight?.allowMethods || Object.values(awsApigatewayv2.CorsHttpMethod),
+        /** Merge default headers with user-defined headers */
+        allowHeaders: [
+          "Content-Type",
+          "Accept",
+          "X-Amz-Date",
+          "Authorization",
+          "X-Api-Key",
+          "X-Amz-Security-Token",
+          "X-Amz-User-Agent",
+          ...props.options?.gatewayOptions?.corsPreflight?.allowHeaders || []
+        ]
+      }
+    });
+    if (!props?.handlerFunctions?.length) {
+      throw new toolkit.CustomException("Construct requires atleast one function");
+    }
+    if (props?.options?.routeOptions?.length) {
+      props.handlerFunctions.forEach((handlerFunc) => {
+        props?.options?.routeOptions.forEach((route) => {
+          this.api.addRoutes({
+            ...route,
+            /**
+             * Lambda integration for each route
+             */
+            integration: new awsApigatewayv2Integrations.HttpLambdaIntegration("routes", handlerFunc)
+          });
+        });
+      });
+    }
+    this.api.applyRemovalPolicy(awsCdkLib.RemovalPolicy.DESTROY);
+    new awsCdkLib.CfnOutput(this, "ApiGatewayV2", {
+      value: this.api.url
+    });
+  }
+};
+var BaseApiGatewayWebSocketConstruct = class extends constructs.Construct {
+  static {
+    __name(this, "BaseApiGatewayWebSocketConstruct");
+  }
+  /** The created WebSocket API instance */
+  socketApi;
+  /**
+   * @param scope Parent construct
+   * @param id Unique construct identifier
+   * @param props Configuration for API, stage, and route handlers
+   */
+  constructor(scope, id, props) {
+    super(scope, id);
+    this.socketApi = new awsApigatewayv2.WebSocketApi(this, id, {
+      ...props.options.webSocketApiOptions,
+      /**
+       * Route for connection establishment ($connect)
+       */
+      connectRouteOptions: {
+        ...props.handlers.connect?.option,
+        integration: new awsApigatewayv2Integrations.WebSocketLambdaIntegration("connectIntegration", props.handlers.connect.function)
+      },
+      /**
+       * Route for disconnection events ($disconnect)
+       */
+      disconnectRouteOptions: {
+        ...props.handlers.disconnect?.option,
+        integration: new awsApigatewayv2Integrations.WebSocketLambdaIntegration("disconnectIntegration", props.handlers.disconnect.function)
+      },
+      /**
+       * Default route for unmatched messages ($default)
+       */
+      defaultRouteOptions: {
+        ...props.handlers.default?.option,
+        integration: new awsApigatewayv2Integrations.WebSocketLambdaIntegration("defaultIntegration", props.handlers.default.function)
+      }
+    });
+    this.socketApi.addRoute("notifications", {
+      ...props.handlers.message?.option,
+      /** Lambda integration for message handling */
+      integration: new awsApigatewayv2Integrations.WebSocketLambdaIntegration("routes", props.handlers.message.function)
+    });
+    const webSocketStage = new awsApigatewayv2.WebSocketStage(this, `${id}_stage`, {
+      ...props.options?.webSocketStageOptions,
+      webSocketApi: this.socketApi,
+      autoDeploy: true
+    });
+    new awsCdkLib.CfnOutput(this, "WebSocketURL", {
+      value: webSocketStage.url
+    });
+  }
+};
+var BaseCloudfrontConstruct = class extends constructs.Construct {
+  static {
+    __name(this, "BaseCloudfrontConstruct");
+  }
+  /** The created CloudFront distribution instance */
+  distribution;
+  /**
+   * @param scope Parent construct
+   * @param id Unique construct identifier
+   * @param props Configuration for CloudFront distribution
+   */
+  constructor(scope, id, props) {
+    super(scope, id);
+    this.distribution = new awsCloudfront.Distribution(this, id, {
+      ...props.options?.cloudfrontOptions,
+      /**
+       * Default behaviour configuration
+       * Enforces HTTPS if not explicitly defined
+       */
+      defaultBehavior: {
+        ...props.options?.cloudfrontOptions?.defaultBehavior,
+        viewerProtocolPolicy: props.options?.cloudfrontOptions?.defaultBehavior?.viewerProtocolPolicy || awsCloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS
+      },
+      /**
+       * Error response configuration
+       *
+       * Adds SPA-friendly fallbacks:
+       * - 400, 403, 404 responses are redirected to index.html
+       */
+      errorResponses: [
+        ...props.options?.cloudfrontOptions?.errorResponses || [],
+        /** Handle 400 errors */
+        {
+          httpStatus: 400,
+          responseHttpStatus: 200,
+          responsePagePath: "/index.html",
+          ttl: awsCdkLib.Duration.days(1)
+        },
+        /** Handle 403 errors */
+        {
+          httpStatus: 403,
+          responseHttpStatus: 200,
+          responsePagePath: "/index.html",
+          ttl: awsCdkLib.Duration.days(1)
+        },
+        /** Handle 404 errors */
+        {
+          httpStatus: 404,
+          responseHttpStatus: 200,
+          responsePagePath: "/index.html",
+          ttl: awsCdkLib.Duration.days(1)
+        }
+      ]
+    });
+  }
+};
+var BaseCloudwatchLogGroupConstruct = class extends constructs.Construct {
+  static {
+    __name(this, "BaseCloudwatchLogGroupConstruct");
+  }
+  /** The created CloudWatch Log Group instance */
+  logGroup;
+  /**
+   * @param scope Parent construct
+   * @param id Unique construct identifier
+   * @param props Configuration for the log group
+   */
+  constructor(scope, id, props) {
+    super(scope, id);
+    this.logGroup = new awsLogs.LogGroup(this, id, {
+      ...props.options?.logGroupOptions,
+      /**
+       * Removal policy applied to the log group
+       * Defaults to DESTROY when not explicitly defined
+       */
+      removalPolicy: props?.options?.logGroupOptions?.removalPolicy || awsCdkLib.RemovalPolicy.DESTROY,
+      /**
+       * Log retention period
+       * Defaults to INFINITE when not explicitly defined
+       */
+      retention: props?.options?.logGroupOptions?.retention || awsLogs.RetentionDays.INFINITE
+    });
+    new awsCdkLib.CfnOutput(this, "CloudwatchArn", {
+      value: this.logGroup.logGroupArn
+    });
+  }
+};
+var BaseDynamoDBConstruct = class _BaseDynamoDBConstruct extends constructs.Construct {
+  static {
+    __name(this, "BaseDynamoDBConstruct");
+  }
+  /** Newly created DynamoDB table (null if importing existing table) */
+  table;
+  /** Imported DynamoDB table reference (null if creating new table) */
+  existingTable;
+  /** Enables debug logging */
+  enableDebug = false;
+  /**
+   * @param scope Parent construct
+   * @param id Unique construct identifier
+   * @param props Configuration for table creation or import
+   */
+  constructor(scope, id, props) {
+    super(scope, id);
+    this.enableDebug = props?.enableDebug;
+    if (props.options?.fromExistingTableName) {
+      this.table = null;
+      this.existingTable = awsDynamodb.Table.fromTableName(
+        this,
+        `${id}-RefName`,
+        props.options.fromExistingTableName
+      );
+      if (this.enableDebug) {
+        toolkit.printLog(
+          _BaseDynamoDBConstruct.name,
+          `Created Dynamo-DB table from existing using name ${props.options?.fromExistingTableName}`
+        );
+      }
+    } else if (props.options?.fromExistingTableArn) {
+      this.table = null;
+      this.existingTable = awsDynamodb.Table.fromTableArn(
+        this,
+        `${id}-RefArn`,
+        props.options.fromExistingTableArn
+      );
+      if (this.enableDebug) {
+        toolkit.printLog(
+          _BaseDynamoDBConstruct.name,
+          `Created Dynamo-DB table from existing using ARN`
+        );
+      }
+    } else if (props.options?.fromExistingTableAttributes) {
+      this.table = null;
+      this.existingTable = awsDynamodb.Table.fromTableAttributes(
+        this,
+        `${id}-RefAttributes`,
+        props.options.fromExistingTableAttributes
+      );
+      if (this.enableDebug) {
+        toolkit.printLog(
+          _BaseDynamoDBConstruct.name,
+          `Created Dynamo-DB table from existing attributes`
+        );
+      }
+    } else {
+      this.existingTable = null;
+      this.table = new awsDynamodb.Table(this, id, {
+        ...props.options?.tableOptions,
+        /**
+         * Billing mode defaults to PAY_PER_REQUEST if not provided
+         */
+        billingMode: props.options?.tableOptions?.billingMode || awsDynamodb.BillingMode.PAY_PER_REQUEST,
+        /**
+         * Deletion protection:
+         * - Uses explicit value if provided
+         * - Defaults to true in production stage
+         */
+        deletionProtection: props.options?.tableOptions?.deletionProtection === true || props.options?.tableOptions?.deletionProtection === false ? props.options.tableOptions.deletionProtection : props.stage === "production"
+      });
+      if (props.options?.globalSecondaryIndexes?.length) {
+        props.options.globalSecondaryIndexes.forEach((globalIndex) => {
+          this.table.addGlobalSecondaryIndex(globalIndex);
+          if (this.enableDebug) {
+            toolkit.printLog(
+              _BaseDynamoDBConstruct.name,
+              `Added GSI: ${globalIndex.indexName}`
+            );
+          }
+        });
+      }
+      if (props.options?.localSecondaryIndexes?.length) {
+        props.options.localSecondaryIndexes.forEach((localIndex) => {
+          this.table.addLocalSecondaryIndex(localIndex);
+          if (this.enableDebug) {
+            toolkit.printLog(
+              _BaseDynamoDBConstruct.name,
+              `Added LSI: ${localIndex.indexName}`
+            );
+          }
+        });
+      }
+    }
+    new awsCdkLib.CfnOutput(this, "DynamoDbArn", {
+      value: props.options?.fromExistingTableName || props.options?.fromExistingTableArn ? this.existingTable.tableArn : this.table.tableArn
+    });
+  }
+};
+var BaseEventBridgeConstruct = class extends constructs.Construct {
+  static {
+    __name(this, "BaseEventBridgeConstruct");
+  }
+  /** The created EventBridge rule instance */
+  eventSchedule;
+  /**
+   * @param scope Parent construct
+   * @param id Unique construct identifier
+   * @param props Configuration for rule and target functions
+   */
+  constructor(scope, id, props) {
+    super(scope, id);
+    this.eventSchedule = new awsEvents.Rule(this, id, {
+      ...props.options?.eventBridgeOptions,
+      /** Default description if not explicitly provided */
+      description: props?.options?.eventBridgeOptions?.description || "An Event-bridge rule"
+    });
+    if (props.options?.targetFunctions?.length) {
+      props.options.targetFunctions.forEach((targetFunction) => {
+        this.eventSchedule.addTarget(
+          /**
+           * Lambda target integration
+           */
+          new awsEventsTargets.LambdaFunction(targetFunction)
+        );
+      });
+    }
+    this.eventSchedule.applyRemovalPolicy(awsCdkLib.RemovalPolicy.DESTROY);
+    new awsCdkLib.CfnOutput(this, "EventBridgeArn", {
+      value: this.eventSchedule.ruleArn
+    });
+  }
+};
+var BaseLambdaAuthoriserConstruct = class extends constructs.Construct {
+  static {
+    __name(this, "BaseLambdaAuthoriserConstruct");
+  }
+  /** The created Token Authorizer instance */
+  authoriser;
+  /**
+   * @param scope Parent construct
+   * @param id Unique construct identifier
+   * @param props Configuration for authorizer and handler function
+   */
+  constructor(scope, id, props) {
+    super(scope, id);
+    this.authoriser = new awsApigateway.TokenAuthorizer(this, id, {
+      ...props.options?.authorizerOptions,
+      /**
+       * Lambda handler responsible for request authorization
+       */
+      handler: props.handlerFunction
+    });
+    new awsCdkLib.CfnOutput(this, "LambdaAuthorizerArn", {
+      value: this.authoriser.authorizerArn
+    });
+  }
+};
+var BaseLambdaAuthoriserV2Construct = class extends constructs.Construct {
+  static {
+    __name(this, "BaseLambdaAuthoriserV2Construct");
+  }
+  /** The created HTTP Lambda Authorizer instance */
+  authoriser;
+  /**
+   * @param scope Parent construct
+   * @param id Unique construct identifier
+   * @param props Configuration for authorizer and handler function
+   */
+  constructor(scope, id, props) {
+    super(scope, id);
+    this.authoriser = new awsApigatewayv2Authorizers.HttpLambdaAuthorizer(id, props.handlerFunction, {
+      ...props?.options?.authorizerOptions,
+      /**
+       * Identity sources used to extract credentials from incoming requests
+       * Defaults to Cookie and Authorization headers
+       */
+      identitySource: [
+        "$request.header.Cookie",
+        "$request.header.Authorization",
+        ...props?.options?.authorizerOptions?.identitySource
+      ],
+      /**
+       * Supported response types for the authorizer
+       * Defaults to IAM and SIMPLE responses
+       */
+      responseTypes: props?.options?.authorizerOptions?.responseTypes || [awsApigatewayv2Authorizers.HttpLambdaResponseType.IAM, awsApigatewayv2Authorizers.HttpLambdaResponseType.SIMPLE]
+    });
+    new awsCdkLib.CfnOutput(this, "LambdaAuthorizerV2_ID", {
+      value: this.authoriser.authorizerId
+    });
+  }
+};
+var BaseLambdaConstruct = class extends constructs.Construct {
+  static {
+    __name(this, "BaseLambdaConstruct");
+  }
+  /** The created Lambda function instance */
+  function;
+  /**
+   * @param scope Parent construct
+   * @param id Unique construct identifier
+   * @param props Configuration for Lambda function
+   */
+  constructor(scope, id, props) {
+    super(scope, id);
+    const environment = {
+      ...props.options?.lambdaOptions?.environment,
+      NODE_ENV: props.stage,
+      NODE_OPTIONS: "--enable-source-maps",
+      AWS_NODEJS_CONNECTION_REUSE_ENABLED: "1"
+    };
+    toolkit.detectDuplicateProperties({ data: environment });
+    this.function = new awsLambda.Function(this, id, {
+      ...props?.options?.lambdaOptions,
+      /**
+       * Lambda function name
+       * Defaults to "<stackName>-handler" if not provided
+       */
+      functionName: `${props?.options?.lambdaOptions?.functionName || props?.stackName}-handler`,
+      /**
+       * Function description
+       */
+      description: props?.options?.lambdaOptions?.description || "A lambda function",
+      /**
+       * Entry handler for the Lambda function
+       */
+      handler: props?.options?.lambdaOptions?.handler || "lambda.handler",
+      /**
+       * Runtime environment
+       */
+      runtime: props?.options?.lambdaOptions?.runtime || awsLambda.Runtime.NODEJS_24_X,
+      /**
+       * Execution timeout
+       * - 30 seconds in production
+       * - 15 seconds otherwise
+       */
+      timeout: props?.options?.lambdaOptions?.timeout || awsCdkLib.Duration.seconds(
+        props.stage === toolkit.AppEnvironmentEnum.PRODUCTION ? 30 : 15
+      ),
+      /**
+       * Memory allocation (in MB)
+       */
+      memorySize: props?.options?.lambdaOptions?.memorySize || 1024,
+      /**
+       * CPU architecture
+       */
+      architecture: props?.options?.lambdaOptions?.architecture || awsLambda.Architecture.ARM_64,
+      /**
+       * Lambda deployment package source
+       */
+      code: props?.options?.lambdaOptions?.code || awsLambda.Code.fromAsset("dist"),
+      /**
+       * Final merged environment variables
+       */
+      environment
+    });
+    new awsCdkLib.CfnOutput(this, "LambdaFunctionArn", {
+      value: this.function.functionArn
+    });
+  }
+};
+var BaseLambdaLayerConstruct = class extends constructs.Construct {
+  static {
+    __name(this, "BaseLambdaLayerConstruct");
+  }
+  /** Newly created Lambda Layer (null if importing existing layer) */
+  layer;
+  /** Imported Lambda Layer reference (null if creating new layer) */
+  existingLayer;
+  /**
+   * @param scope Parent construct
+   * @param id Unique construct identifier
+   * @param props Configuration for layer creation or import
+   */
+  constructor(scope, id, props) {
+    super(scope, id);
+    if (props?.options?.fromExistingLayerArn) {
+      this.existingLayer = awsLambda.LayerVersion.fromLayerVersionArn(
+        this,
+        `${id}-Arn`,
+        props?.options?.fromExistingLayerArn
+      );
+    } else if (props?.options?.fromExistingLayerAttribute) {
+      this.existingLayer = awsLambda.LayerVersion.fromLayerVersionAttributes(
+        this,
+        `${id}-Attribute`,
+        props?.options?.fromExistingLayerAttribute
+      );
+    } else {
+      this.layer = new awsLambda.LayerVersion(this, id, {
+        ...props.options?.layerOptions,
+        /**
+         * Default layer code asset
+         */
+        code: props?.options?.layerOptions?.code || awsLambda.Code.fromAsset("./dist-layer"),
+        /**
+         * Layer description
+         */
+        description: props?.options?.layerOptions?.description || "Lambda Layer written in NodeJS, NestJS, NodeJS-express, serverless-express",
+        /**
+         * Supported CPU architectures
+         */
+        compatibleArchitectures: [
+          awsLambda.Architecture.ARM_64,
+          awsLambda.Architecture.X86_64
+        ],
+        /**
+         * Supported runtimes
+         */
+        compatibleRuntimes: [
+          awsLambda.Runtime.NODEJS_22_X,
+          awsLambda.Runtime.NODEJS_24_X,
+          awsLambda.Runtime.NODEJS_LATEST
+        ]
+      });
+    }
+    new awsCdkLib.CfnOutput(this, "LambdaLayerArn", {
+      value: props.options?.fromExistingLayerArn || props.options?.fromExistingLayerAttribute ? this.existingLayer.layerVersionArn : this.layer.layerVersionArn
+    });
+  }
+};
+var BaseRolePolicyConstruct = class extends constructs.Construct {
+  static {
+    __name(this, "BaseRolePolicyConstruct");
+  }
+  /** The created IAM Role instance */
+  role;
+  /**
+   * @param scope Parent construct
+   * @param id Unique construct identifier
+   * @param props Configuration for role and policies
+   */
+  constructor(scope, id, props) {
+    super(scope, id);
+    this.role = new awsIam.Role(this, id, {
+      ...props.options?.roleOptions,
+      /**
+       * Managed policies attached to the role
+       * Defaults to AWSLambdaBasicExecutionRole if not provided
+       */
+      managedPolicies: props.options?.roleOptions?.managedPolicies ? props.options.roleOptions.managedPolicies : [
+        awsIam.ManagedPolicy.fromAwsManagedPolicyName(
+          "service-role/AWSLambdaBasicExecutionRole"
+        )
+      ]
+    });
+    if (props?.policies?.length) {
+      props.policies.forEach((policy) => {
+        this.role.addToPolicy(
+          /**
+           * Inline policy statement
+           */
+          new awsIam.PolicyStatement(policy)
+        );
+      });
+    }
+    this.role.applyRemovalPolicy(awsCdkLib.RemovalPolicy.DESTROY);
+    new awsCdkLib.CfnOutput(this, "RolePolicyArn", {
+      value: this.role.roleArn
+    });
+  }
+};
+var BaseS3Construct = class extends constructs.Construct {
+  static {
+    __name(this, "BaseS3Construct");
+  }
+  /** The created S3 bucket instance */
+  bucket;
+  /**
+   * @param scope Parent construct
+   * @param id Unique construct identifier
+   * @param props Configuration for S3 bucket
+   */
+  constructor(scope, id, props) {
+    super(scope, id);
+    this.bucket = new awsS3.Bucket(this, id, {
+      ...props.options?.bucketOptions,
+      /**
+       * Removal policy applied to the bucket
+       * Defaults to DESTROY if not explicitly defined
+       */
+      removalPolicy: props.options?.bucketOptions?.removalPolicy || awsCdkLib.RemovalPolicy.DESTROY
+    });
+    new awsCdkLib.CfnOutput(this, "S3BucketArn", {
+      value: this.bucket.bucketArn
+    });
+  }
+};
+var BaseS3DeploymentConstruct = class extends constructs.Construct {
+  static {
+    __name(this, "BaseS3DeploymentConstruct");
+  }
+  /** The created or provided S3 bucket */
+  bucket;
+  /** The created CloudFront distribution */
+  distribution;
+  /** S3 bucket deployment instance */
+  bucketDeployment;
+  /**
+   * @param scope Parent construct
+   * @param id Unique construct identifier
+   * @param props Configuration for bucket, distribution, and deployment
+   */
+  constructor(scope, id, props) {
+    super(scope, id);
+    if (!props.options?.cloudfrontOptions?.defaultBehavior?.origin && !props?.withS3Bucket && props.withCloudfront) {
+      throw new toolkit.CustomException("Cloudfront distribution S3_Bucket origins must be defined!");
+    }
+    if (!props.options?.bucketDeploymentOptions?.destinationBucket && !props?.withS3Bucket) {
+      throw new toolkit.CustomException("Deployment S3_Bucket destination must be defined!");
+    }
+    if (props?.withS3Bucket) {
+      this.bucket = new BaseS3Construct(this, "bucket", {
+        enableDebug: props.enableDebug,
+        options: { bucketOptions: props.options?.bucketOptions }
+      }).bucket;
+    }
+    if (props?.withCloudfront) {
+      const s3Origin = props.options?.cloudfrontOptions?.defaultBehavior?.origin || awsCloudfrontOrigins.S3BucketOrigin.withOriginAccessControl(this.bucket);
+      this.distribution = new BaseCloudfrontConstruct(this, "distribution", {
+        enableDebug: props.enableDebug,
+        options: {
+          cloudfrontOptions: {
+            ...props.options?.cloudfrontOptions,
+            /**
+             * 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;
+            }, {}),
+            /**
+             * Default behavior configuration
+             */
+            defaultBehavior: {
+              ...props.options?.cloudfrontOptions?.defaultBehavior,
+              origin: s3Origin
+            }
+          }
+        }
+      }).distribution;
+    }
+    this.bucketDeployment = new awsS3Deployment.BucketDeployment(this, "deployment", {
+      ...props.options?.bucketDeploymentOptions,
+      /** Target distribution for cache invalidation */
+      distribution: props.options?.bucketDeploymentOptions?.distribution || this.distribution,
+      /** Paths to invalidate after deployment */
+      distributionPaths: props.options?.bucketDeploymentOptions?.distributionPaths || ["/*"],
+      /** Destination S3 bucket */
+      destinationBucket: props.options?.bucketDeploymentOptions?.destinationBucket || this.bucket
+    });
+  }
+};
+var BaseSnsConstruct = class extends constructs.Construct {
+  static {
+    __name(this, "BaseSnsConstruct");
+  }
+  /** The created SNS topic instance */
+  topic;
+  /**
+   * @param scope Parent construct
+   * @param id Unique construct identifier
+   * @param props Configuration for topic and subscriptions
+   */
+  constructor(scope, id, props) {
+    super(scope, id);
+    this.topic = new awsSns.Topic(this, id, props.options?.topicOptions);
+    if (props.options?.targetFunctions?.length) {
+      props.options.targetFunctions.forEach((targetFunction) => {
+        this.topic.addSubscription(
+          /**
+           * Lambda subscription target
+           */
+          new awsSnsSubscriptions.LambdaSubscription(targetFunction)
+        );
+      });
+    }
+    this.topic.applyRemovalPolicy(awsCdkLib.RemovalPolicy.DESTROY);
+    new awsCdkLib.CfnOutput(this, "SnsTopicArn", {
+      value: this.topic.topicArn
+    });
+  }
+};
+var BaseSqsConstruct = class extends constructs.Construct {
+  static {
+    __name(this, "BaseSqsConstruct");
+  }
+  /** The created SQS queue instance */
+  queue;
+  /**
+   * @param scope Parent construct
+   * @param id Unique construct identifier
+   * @param props Configuration for queue and Lambda consumers
+   */
+  constructor(scope, id, props) {
+    super(scope, id);
+    this.queue = new awsSqs.Queue(this, id, {
+      ...props?.options?.queueOptions,
+      /**
+       * Removal policy applied to the queue
+       * Defaults to DESTROY if not explicitly defined
+       */
+      removalPolicy: props?.options?.queueOptions?.removalPolicy || awsCdkLib.RemovalPolicy.DESTROY
+    });
+    if (props?.targetFunctions?.length) {
+      props.targetFunctions.forEach((targetFunction, index) => {
+        new awsLambda.EventSourceMapping(this, `${id}-eventSourceMap${index + 1}`, {
+          ...props?.options?.eventSourceMappingOptions,
+          /** Target Lambda function */
+          target: targetFunction,
+          /** Source SQS queue ARN */
+          eventSourceArn: this.queue.queueArn,
+          /**
+           * Retry attempts for failed batch processing
+           * Defaults to 3 if not explicitly defined
+           */
+          retryAttempts: props?.options?.eventSourceMappingOptions?.retryAttempts || 3
+        });
+      });
+    }
+    new awsCdkLib.CfnOutput(this, "SqsQueueArn", {
+      value: this.queue.queueArn
+    });
+  }
+};
+var BaseVpcConstruct = class extends constructs.Construct {
+  static {
+    __name(this, "BaseVpcConstruct");
+  }
+  /** The created VPC instance */
+  vpc;
+  /**
+   * @param scope Parent construct
+   * @param id Unique construct identifier
+   * @param props Configuration for VPC
+   */
+  constructor(scope, id, props) {
+    super(scope, id);
+    this.vpc = new awsEc2.Vpc(this, id, {
+      ...props.options.vpcOptions
+    });
+    new awsCdkLib.CfnOutput(this, "VpcArn", {
+      value: this.vpc.vpcArn
+    });
+  }
+};
+
+exports.BaseApiGatewayConstruct = BaseApiGatewayConstruct;
+exports.BaseApiGatewayV2Construct = BaseApiGatewayV2Construct;
+exports.BaseApiGatewayWebSocketConstruct = BaseApiGatewayWebSocketConstruct;
+exports.BaseCloudfrontConstruct = BaseCloudfrontConstruct;
+exports.BaseCloudwatchLogGroupConstruct = BaseCloudwatchLogGroupConstruct;
+exports.BaseDynamoDBConstruct = BaseDynamoDBConstruct;
+exports.BaseEventBridgeConstruct = BaseEventBridgeConstruct;
+exports.BaseLambdaAuthoriserConstruct = BaseLambdaAuthoriserConstruct;
+exports.BaseLambdaAuthoriserV2Construct = BaseLambdaAuthoriserV2Construct;
+exports.BaseLambdaConstruct = BaseLambdaConstruct;
+exports.BaseLambdaLayerConstruct = BaseLambdaLayerConstruct;
+exports.BaseRolePolicyConstruct = BaseRolePolicyConstruct;
+exports.BaseS3Construct = BaseS3Construct;
+exports.BaseS3DeploymentConstruct = BaseS3DeploymentConstruct;
+exports.BaseSnsConstruct = BaseSnsConstruct;
+exports.BaseSqsConstruct = BaseSqsConstruct;
+exports.BaseVpcConstruct = BaseVpcConstruct;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map