@gradientedge/cdk-utils 8.120.0 → 8.122.0

package/README.md

@@ -25,7 +25,7 @@
 
 ## Introduction
 
-Toolkit for working with the [AWS CDK][aws-cdk].
+Toolkit for working with CDK Constructs ([AWS CDK][aws-cdk] & [CDK for Terraform][cdktf]).
 
 For more details, see the full [API documentation](https://gradientedge.github.io/cdk-utils/).
 
@@ -65,6 +65,7 @@ pnpm add @gradientedge/cdk-utils
 [builds]: https://img.shields.io/github/actions/workflow/status/gradientedge/cdk-utils/ci.yml?branch=main
 [builds-url]: https://github.com/gradientedge/cdk-utils/actions
 [cdk-badge]: https://img.shields.io/github/package-json/dependency-version/gradientedge/cdk-utils/aws-cdk-lib
+[cdktf]: https://developer.hashicorp.com/terraform/cdktf
 [cdk-url]: https://aws.amazon.com/cdk/
 [checks]: https://img.shields.io/github/checks-status/gradientedge/cdk-utils/main
 [cmd]: https://img.shields.io/badge/command--line-4D4D4D?logo=windows-terminal&style=for-the-badge

package/dist/index.d.ts

@@ -1,5 +1 @@
-export * from './src/lib/common';
-export * from './src/lib/construct';
-export * from './src/lib/services';
-export * from './src/lib/types';
-export * from './src/lib/utils';
+export * from './src/lib';

package/dist/index.js

@@ -14,8 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./src/lib/common"), exports);
-__exportStar(require("./src/lib/construct"), exports);
-__exportStar(require("./src/lib/services"), exports);
-__exportStar(require("./src/lib/types"), exports);
-__exportStar(require("./src/lib/utils"), exports);
+__exportStar(require("./src/lib"), exports);

package/dist/src/lib/aws/common/construct.d.ts

@@ -0,0 +1,83 @@
+import { CfnOutput } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+import { AcmManager, ApiManager, AppConfigManager, CloudFrontManager, CloudTrailManager, CloudWatchManager, CodeBuildManager, DynamodbManager, EcrManager, EcsManager, EfsManager, EksManager, ElastiCacheManager, EventManager, EventTargetManager, EvidentlyManager, IamManager, KmsManager, LambdaManager, LogManager, Route53Manager, S3Manager, SecretsManager, SfnManager, SnsManager, SqsManager, SsmManager, VpcManager, WafManager } from '../services';
+import { CommonStackProps } from './types';
+/**
+ * @subcategory Construct
+ * @classdesc Common construct to use as a base for all higher level constructs.
+ * @example
+ * import { CommonConstruct } from '@gradientedge/cdk-utils';
+ *
+ * class CustomConstruct extends CommonConstruct {
+ *   constructor(parent: cdk.Construct, id: string, props: common.CommonStackProps) {
+ *     super(parent, id, props);
+ *     this.props = props;
+ *   };
+ * };
+ */
+export declare class CommonConstruct extends Construct {
+    props: CommonStackProps;
+    acmManager: AcmManager;
+    apiManager: ApiManager;
+    appConfigManager: AppConfigManager;
+    codeBuildManager: CodeBuildManager;
+    cloudFrontManager: CloudFrontManager;
+    cloudTrailManager: CloudTrailManager;
+    cloudWatchManager: CloudWatchManager;
+    dynamodbManager: DynamodbManager;
+    ecrManager: EcrManager;
+    ecsManager: EcsManager;
+    efsManager: EfsManager;
+    eksManager: EksManager;
+    elasticacheManager: ElastiCacheManager;
+    eventManager: EventManager;
+    eventTargetManager: EventTargetManager;
+    evidentlyManager: EvidentlyManager;
+    iamManager: IamManager;
+    kmsManager: KmsManager;
+    lambdaManager: LambdaManager;
+    logManager: LogManager;
+    route53Manager: Route53Manager;
+    s3Manager: S3Manager;
+    secretsManager: SecretsManager;
+    sfnManager: SfnManager;
+    snsManager: SnsManager;
+    sqsManager: SqsManager;
+    ssmManager: SsmManager;
+    vpcManager: VpcManager;
+    wafManager: WafManager;
+    fullyQualifiedDomainName: string;
+    constructor(parent: Construct, id: string, props: CommonStackProps);
+    /**
+     * @summary Helper method to add CloudFormation outputs from the construct
+     * @param id scoped id of the resource
+     * @param value the value of the exported output
+     * @param description optional description for the output
+     * @param overrideId Flag which indicates whether to override the default logical id of the output
+     */
+    protected addCfnOutput(id: string, value: string, description?: string, overrideId?: boolean): CfnOutput;
+    /**
+     * @summary Determine the fully qualified domain name based on domainName & subDomain
+     */
+    protected determineFullyQualifiedDomain(): void;
+    /**
+     * @summary Utility method to determine if the initialisation is in development (dev) stage
+     * This is determined by the stage property injected via cdk context
+     */
+    isDevelopmentStage: () => boolean;
+    /**
+     * @summary Utility method to determine if the initialisation is in test (tst) stage
+     * This is determined by the stage property injected via cdk context
+     */
+    isTestStage: () => boolean;
+    /**
+     * @summary Utility method to determine if the initialisation is in uat (uat) stage
+     * This is determined by the stage property injected via cdk context
+     */
+    isUatStage: () => boolean;
+    /**
+     * @summary Utility method to determine if the initialisation is in production (prd) stage
+     * This is determined by the stage property injected via cdk context
+     */
+    isProductionStage: () => boolean;
+}

package/dist/src/lib/aws/common/construct.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonConstruct = void 0;
+const constructs_1 = require("constructs");
+const common_1 = require("../../common");
+const services_1 = require("../services");
+const utils_1 = require("../utils");
+/**
+ * @subcategory Construct
+ * @classdesc Common construct to use as a base for all higher level constructs.
+ * @example
+ * import { CommonConstruct } from '@gradientedge/cdk-utils';
+ *
+ * class CustomConstruct extends CommonConstruct {
+ *   constructor(parent: cdk.Construct, id: string, props: common.CommonStackProps) {
+ *     super(parent, id, props);
+ *     this.props = props;
+ *   };
+ * };
+ */
+class CommonConstruct extends constructs_1.Construct {
+    props;
+    acmManager;
+    apiManager;
+    appConfigManager;
+    codeBuildManager;
+    cloudFrontManager;
+    cloudTrailManager;
+    cloudWatchManager;
+    dynamodbManager;
+    ecrManager;
+    ecsManager;
+    efsManager;
+    eksManager;
+    elasticacheManager;
+    eventManager;
+    eventTargetManager;
+    evidentlyManager;
+    iamManager;
+    kmsManager;
+    lambdaManager;
+    logManager;
+    route53Manager;
+    s3Manager;
+    secretsManager;
+    sfnManager;
+    snsManager;
+    sqsManager;
+    ssmManager;
+    vpcManager;
+    wafManager;
+    fullyQualifiedDomainName;
+    constructor(parent, id, props) {
+        super(parent, id);
+        this.props = props;
+        this.acmManager = new services_1.AcmManager();
+        this.apiManager = new services_1.ApiManager();
+        this.appConfigManager = new services_1.AppConfigManager();
+        this.codeBuildManager = new services_1.CodeBuildManager();
+        this.cloudFrontManager = new services_1.CloudFrontManager();
+        this.cloudTrailManager = new services_1.CloudTrailManager();
+        this.cloudWatchManager = new services_1.CloudWatchManager();
+        this.dynamodbManager = new services_1.DynamodbManager();
+        this.ecrManager = new services_1.EcrManager();
+        this.ecsManager = new services_1.EcsManager();
+        this.efsManager = new services_1.EfsManager();
+        this.eksManager = new services_1.EksManager();
+        this.elasticacheManager = new services_1.ElastiCacheManager();
+        this.eventManager = new services_1.EventManager();
+        this.eventTargetManager = new services_1.EventTargetManager();
+        this.evidentlyManager = new services_1.EvidentlyManager();
+        this.iamManager = new services_1.IamManager();
+        this.kmsManager = new services_1.KmsManager();
+        this.lambdaManager = new services_1.LambdaManager();
+        this.logManager = new services_1.LogManager();
+        this.route53Manager = new services_1.Route53Manager();
+        this.s3Manager = new services_1.S3Manager();
+        this.secretsManager = new services_1.SecretsManager();
+        this.sfnManager = new services_1.SfnManager();
+        this.snsManager = new services_1.SnsManager();
+        this.sqsManager = new services_1.SqsManager();
+        this.ssmManager = new services_1.SsmManager();
+        this.vpcManager = new services_1.VpcManager();
+        this.wafManager = new services_1.WafManager();
+        this.determineFullyQualifiedDomain();
+    }
+    /**
+     * @summary Helper method to add CloudFormation outputs from the construct
+     * @param id scoped id of the resource
+     * @param value the value of the exported output
+     * @param description optional description for the output
+     * @param overrideId Flag which indicates whether to override the default logical id of the output
+     */
+    addCfnOutput(id, value, description, overrideId = true) {
+        return (0, utils_1.createCfnOutput)(id, this, value, description, overrideId);
+    }
+    /**
+     * @summary Determine the fully qualified domain name based on domainName & subDomain
+     */
+    determineFullyQualifiedDomain() {
+        this.fullyQualifiedDomainName = this.props.subDomain
+            ? `${this.props.subDomain}.${this.props.domainName}`
+            : this.props.domainName;
+    }
+    /**
+     * @summary Utility method to determine if the initialisation is in development (dev) stage
+     * This is determined by the stage property injected via cdk context
+     */
+    isDevelopmentStage = () => (0, common_1.isDevStage)(this.props.stage);
+    /**
+     * @summary Utility method to determine if the initialisation is in test (tst) stage
+     * This is determined by the stage property injected via cdk context
+     */
+    isTestStage = () => (0, common_1.isTestStage)(this.props.stage);
+    /**
+     * @summary Utility method to determine if the initialisation is in uat (uat) stage
+     * This is determined by the stage property injected via cdk context
+     */
+    isUatStage = () => (0, common_1.isUatStage)(this.props.stage);
+    /**
+     * @summary Utility method to determine if the initialisation is in production (prd) stage
+     * This is determined by the stage property injected via cdk context
+     */
+    isProductionStage = () => (0, common_1.isPrdStage)(this.props.stage);
+}
+exports.CommonConstruct = CommonConstruct;

package/dist/src/lib/aws/common/index.d.ts

@@ -0,0 +1,3 @@
+export * from './construct';
+export * from './stack';
+export * from './types';

package/dist/src/lib/aws/common/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./construct"), exports);
+__exportStar(require("./stack"), exports);
+__exportStar(require("./types"), exports);

package/dist/src/lib/aws/common/stack.d.ts

@@ -0,0 +1,56 @@
+import { App, Stack, StackProps } from 'aws-cdk-lib';
+import { Runtime } from 'aws-cdk-lib/aws-lambda';
+import { CommonConstruct } from './construct';
+import { CommonStackProps } from './types';
+/**
+ * @classdesc Common stack to use as a base for all higher level constructs.
+ * @example
+ * import { CommonStack } from '@gradientedge/cdk-utils'
+ *
+ * class CustomStack extends CommonStack {
+ *   constructor(parent: App, name: string, props: StackProps) {
+ *     super(parent, name, props)
+ *     // provision resources
+ *   }
+ * }
+ */
+export declare class CommonStack extends Stack {
+    static NODEJS_RUNTIME: Runtime;
+    construct: CommonConstruct;
+    props: CommonStackProps;
+    constructor(parent: App, name: string, props: StackProps);
+    /**
+     * @summary Method to determine the core CDK construct properties injected via context cdk.json
+     * @param props The stack properties
+     * @returns The stack properties
+     */
+    protected determineConstructProps(props: StackProps): {
+        domainName: any;
+        excludeDomainNameForBuckets: any;
+        extraContexts: any;
+        logRetention: any;
+        name: string;
+        nodejsRuntime: any;
+        region: any;
+        skipStageForARecords: any;
+        stackName: string | undefined;
+        stage: any;
+        subDomain: any;
+    };
+    /**
+     * @summary Method to determine extra cdk contexts apart from the main cdk.json
+     * - Sets the properties from the extra contexts into cdk node context
+     * - Primary use is to have layered config in separate files to enable easier maintenance and readability
+     */
+    protected determineExtraContexts(): void;
+    /**
+     * @summary Method to determine extra cdk stage contexts apart from the main cdk.json
+     * - Sets the properties from the extra stage contexts into cdk node context
+     * - Primary use is to have layered config for each environment which is injected into the context
+     */
+    protected determineStageContexts(): void;
+    /**
+     * @summary Determine the fully qualified domain name based on domainName & subDomain
+     */
+    protected fullyQualifiedDomain(): any;
+}

package/dist/src/lib/aws/common/stack.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonStack = void 0;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const fs_1 = __importDefault(require("fs"));
+const construct_1 = require("./construct");
+const app_root_path_1 = __importDefault(require("app-root-path"));
+const common_1 = require("../../common");
+/**
+ * @classdesc Common stack to use as a base for all higher level constructs.
+ * @example
+ * import { CommonStack } from '@gradientedge/cdk-utils'
+ *
+ * class CustomStack extends CommonStack {
+ *   constructor(parent: App, name: string, props: StackProps) {
+ *     super(parent, name, props)
+ *     // provision resources
+ *   }
+ * }
+ */
+class CommonStack extends aws_cdk_lib_1.Stack {
+    static NODEJS_RUNTIME = aws_lambda_1.Runtime.NODEJS_18_X;
+    construct;
+    props;
+    constructor(parent, name, props) {
+        super(parent, name, props);
+        /* determine extra cdk contexts */
+        this.determineExtraContexts();
+        /* determine extra cdk stage contexts */
+        this.determineStageContexts();
+        this.props = this.determineConstructProps(props);
+        /* initialise the construct */
+        this.construct = new construct_1.CommonConstruct(this, 'cdk-utils', this.props);
+    }
+    /**
+     * @summary Method to determine the core CDK construct properties injected via context cdk.json
+     * @param props The stack properties
+     * @returns The stack properties
+     */
+    determineConstructProps(props) {
+        return {
+            domainName: this.node.tryGetContext('domainName'),
+            excludeDomainNameForBuckets: this.node.tryGetContext('excludeDomainNameForBuckets'),
+            extraContexts: this.node.tryGetContext('extraContexts'),
+            logRetention: this.node.tryGetContext('logRetention'),
+            name: props.stackName || 'cdk-utils',
+            nodejsRuntime: this.node.tryGetContext('nodejsRuntime') ?? CommonStack.NODEJS_RUNTIME,
+            region: this.node.tryGetContext('region'),
+            skipStageForARecords: this.node.tryGetContext('skipStageForARecords'),
+            stackName: props.stackName,
+            stage: this.node.tryGetContext('stage'),
+            subDomain: this.node.tryGetContext('subDomain'),
+        };
+    }
+    /**
+     * @summary Method to determine extra cdk contexts apart from the main cdk.json
+     * - Sets the properties from the extra contexts into cdk node context
+     * - Primary use is to have layered config in separate files to enable easier maintenance and readability
+     */
+    determineExtraContexts() {
+        const extraContexts = this.node.tryGetContext('extraContexts');
+        const debug = this.node.tryGetContext('debug');
+        if (!extraContexts) {
+            if (debug)
+                console.debug(`No additional contexts provided. Using default context properties from cdk.json`);
+            return;
+        }
+        extraContexts.forEach((context) => {
+            const extraContextPath = `${app_root_path_1.default.path}/${context}`;
+            /* scenario where extra context is configured in cdk.json but absent in file system */
+            if (!fs_1.default.existsSync(extraContextPath))
+                throw `Extra context properties unavailable in path:${extraContextPath}`;
+            /* read the extra properties */
+            const extraContextPropsBuffer = fs_1.default.readFileSync(extraContextPath);
+            if (debug)
+                console.debug(`Adding additional contexts provided in ${extraContextPath}`);
+            /* parse as JSON properties */
+            const extraContextProps = JSON.parse(extraContextPropsBuffer.toString('utf-8'));
+            /* set each of the property into the cdk node context */
+            Object.keys(extraContextProps).forEach((propKey) => {
+                this.node.setContext(propKey, extraContextProps[propKey]);
+            });
+        });
+    }
+    /**
+     * @summary Method to determine extra cdk stage contexts apart from the main cdk.json
+     * - Sets the properties from the extra stage contexts into cdk node context
+     * - Primary use is to have layered config for each environment which is injected into the context
+     */
+    determineStageContexts() {
+        const stage = this.node.tryGetContext('stage');
+        const stageContextPath = this.node.tryGetContext('stageContextPath') || 'cdkEnv';
+        const stageContextFilePath = `${app_root_path_1.default.path}/${stageContextPath}/${stage}.json`;
+        const debug = this.node.tryGetContext('debug');
+        if ((0, common_1.isDevStage)(stage)) {
+            if (debug)
+                console.debug(`Development stage. Using default stage context properties`);
+        }
+        /* alert default context usage when extra stage config is missing */
+        if (!fs_1.default.existsSync(stageContextFilePath)) {
+            if (debug)
+                console.debug(`Stage specific context properties unavailable in path:${stageContextFilePath}`);
+            if (debug)
+                console.debug(`Using default stage context properties for ${stage} stage`);
+            return;
+        }
+        /* read the extra properties */
+        const stageContextPropsBuffer = fs_1.default.readFileSync(stageContextFilePath);
+        if (debug)
+            console.debug(`Adding additional stage contexts provided in ${stageContextFilePath}`);
+        /* parse as JSON properties */
+        const stageContextProps = JSON.parse(stageContextPropsBuffer.toString('utf-8'));
+        /* set each of the property into the cdk node context */
+        Object.keys(stageContextProps).forEach((propKey) => {
+            /* handle object, array properties */
+            if (typeof stageContextProps[propKey] === 'object' && !Array.isArray(stageContextProps[propKey])) {
+                this.node.setContext(propKey, {
+                    ...this.node.tryGetContext(propKey),
+                    ...stageContextProps[propKey],
+                });
+            }
+            else {
+                /* handle all other primitive properties */
+                this.node.setContext(propKey, stageContextProps[propKey]);
+            }
+        });
+    }
+    /**
+     * @summary Determine the fully qualified domain name based on domainName & subDomain
+     */
+    fullyQualifiedDomain() {
+        const domainName = this.node.tryGetContext('domainName');
+        const subDomain = this.node.tryGetContext('subDomain');
+        return subDomain ? `${subDomain}.${domainName}` : domainName;
+    }
+}
+exports.CommonStack = CommonStack;

package/dist/src/lib/aws/common/types.d.ts

@@ -0,0 +1,14 @@
+import { StackProps } from 'aws-cdk-lib';
+import { Runtime, Tracing } from 'aws-cdk-lib/aws-lambda';
+import { RetentionDays } from 'aws-cdk-lib/aws-logs';
+import { BaseProps } from '../../common';
+/**
+ */
+export interface CommonStackProps extends BaseProps, StackProps {
+    region: string;
+    logRetention?: RetentionDays;
+    defaultReservedLambdaConcurrentExecutions?: number;
+    defaultTracing?: Tracing;
+    excludeDomainNameForBuckets?: boolean;
+    nodejsRuntime?: Runtime;
+}

package/dist/src/lib/aws/index.d.ts

@@ -0,0 +1,5 @@
+export * from './common';
+export * from './construct';
+export * from './services';
+export * from './types';
+export * from './utils';

package/dist/src/lib/aws/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./common"), exports);
+__exportStar(require("./construct"), exports);
+__exportStar(require("./services"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);

package/dist/src/lib/aws/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/lib/{utils/aws → aws/utils}/index.d.ts

@@ -1,6 +1,6 @@
 import { AwsCredentialIdentityProvider } from '@aws-sdk/types';
 import { CfnOutput } from 'aws-cdk-lib';
-import { CommonConstruct } from '../../common';
+import { CommonConstruct } from '../common';
 /**
  * @summary Helper method to add CloudFormation outputs from the construct
  * @param id scoped id of the resource
@@ -15,3 +15,31 @@ export declare function createCfnOutput(id: string, scope: CommonConstruct, valu
  *
  */
 export declare function determineCredentials(): AwsCredentialIdentityProvider;
+/**
+ * @param error
+ */
+export declare function redirectError(error: any): {
+    body: string;
+    headers: {
+        'Access-Control-Allow-Origin': string;
+    };
+    isBase64Encoded: boolean;
+    statusCode: number;
+} & {
+    body: string;
+    statusCode: number;
+};
+/**
+ * @param message
+ */
+export declare function redirectSuccess(message: any): {
+    body: string;
+    headers: {
+        'Access-Control-Allow-Origin': string;
+    };
+    isBase64Encoded: boolean;
+    statusCode: number;
+} & {
+    body: string;
+    statusCode: number;
+};

package/dist/src/lib/{utils/aws → aws/utils}/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.determineCredentials = exports.createCfnOutput = void 0;
+exports.redirectSuccess = exports.redirectError = exports.determineCredentials = exports.createCfnOutput = void 0;
 const credential_providers_1 = require("@aws-sdk/credential-providers");
 const aws_cdk_lib_1 = require("aws-cdk-lib");
 const lodash_1 = __importDefault(require("lodash"));
@@ -38,3 +38,34 @@ function determineCredentials() {
     return (0, credential_providers_1.fromEnv)();
 }
 exports.determineCredentials = determineCredentials;
+/**
+ */
+const defaultResponseObject = {
+    body: '',
+    headers: {
+        'Access-Control-Allow-Origin': '*',
+    },
+    isBase64Encoded: false,
+    statusCode: 200,
+};
+/**
+ * @param error
+ */
+function redirectError(error) {
+    console.error(error, error.message, error.stack);
+    return Object.assign({}, defaultResponseObject, {
+        body: JSON.stringify(Object.assign({}, { error: error.message, success: false })),
+        statusCode: 500,
+    });
+}
+exports.redirectError = redirectError;
+/**
+ * @param message
+ */
+function redirectSuccess(message) {
+    return Object.assign({}, defaultResponseObject, {
+        body: JSON.stringify(Object.assign({}, { error: message, success: true })),
+        statusCode: 200,
+    });
+}
+exports.redirectSuccess = redirectSuccess;

package/dist/src/lib/azure/common/construct.d.ts

@@ -0,0 +1,35 @@
+import { TerraformStack } from 'cdktf';
+import { Construct } from 'constructs';
+import { AzureStorageManager } from '../services';
+import { CommonAzureStackProps } from './types';
+export declare class CommonAzureConstruct extends TerraformStack {
+    props: CommonAzureStackProps;
+    id: string;
+    fullyQualifiedDomainName: string;
+    storageManager: AzureStorageManager;
+    constructor(scope: Construct, id: string, props: CommonAzureStackProps);
+    /**
+     * @summary Determine the fully qualified domain name based on domainName & subDomain
+     */
+    protected determineFullyQualifiedDomain(): void;
+    /**
+     * @summary Utility method to determine if the initialisation is in development (dev) stage
+     * This is determined by the stage property injected via cdk context
+     */
+    isDevelopmentStage: () => boolean;
+    /**
+     * @summary Utility method to determine if the initialisation is in test (tst) stage
+     * This is determined by the stage property injected via cdk context
+     */
+    isTestStage: () => boolean;
+    /**
+     * @summary Utility method to determine if the initialisation is in uat (uat) stage
+     * This is determined by the stage property injected via cdk context
+     */
+    isUatStage: () => boolean;
+    /**
+     * @summary Utility method to determine if the initialisation is in production (prd) stage
+     * This is determined by the stage property injected via cdk context
+     */
+    isProductionStage: () => boolean;
+}