@sylvesterllc/aws-constructs 1.0.0

package/src/resources/gateway/createMicroServiceBundle.ts

@@ -0,0 +1,183 @@
+import { IRestApi, TokenAuthorizer } from "aws-cdk-lib/aws-apigateway";
+import { ITable, Table } from "aws-cdk-lib/aws-dynamodb";
+import { NodejsFunction } from "aws-cdk-lib/aws-lambda-nodejs";
+import { Effect, PolicyStatement } from "aws-cdk-lib/aws-iam";
+import { Construct } from "constructs";
+import { TsgDynamoTableRef, TsgLambdaProp } from "../../config/types";
+import { TsgLambdaProps } from "../../config/types/TsgLambdaProps";
+import { MicroserviceProps } from "../../interfaces/MicroserviceProps";
+import { CreateAuthorizer } from "../helpers/createAuthorizer";
+import { Routes } from "../helpers/createRoutes";
+import { CreateLambda } from "../lambda/createLambda";
+import { Duration, Stack } from "aws-cdk-lib";
+import { CreateDynamoDb } from "../dynamodb/CreateDynamo";
+import { ISecret } from "aws-cdk-lib/aws-secretsmanager";
+import { LayerVersion } from "aws-cdk-lib/aws-lambda";
+import { AppConfig } from "../../config/AppConfig";
+import { MetricOptions } from "aws-cdk-lib/aws-cloudwatch";
+
+export class CreateMicroServiceBundle {
+    
+    protected readonly requireDynamoTableRefs: boolean;
+    protected readonly requireAuthorizer: boolean;
+
+    constructor(scope: Construct, 
+        private readonly gatewayApi: IRestApi, 
+        private readonly props: MicroserviceProps,
+        private readonly appConfig: AppConfig,
+        private readonly tables?: Table[], 
+        private readonly secretMgr?: ISecret, 
+        private readonly layers?: LayerVersion[],
+        ) {
+        
+        this.requireDynamoTableRefs = (props.RESOURCES.DYNAMO?.TABLE_REFS?.length ?? 0 > 0) ? true : false;
+        this.requireAuthorizer = (props.RESOURCES.AUTHORIZER) ? true : false;
+        this.onInit(scope);
+    }
+
+    private onInit(scope: Construct) {
+
+        //console.log("ENTER CreateMicroServiceBundle.onInit");
+        let authorizer: TokenAuthorizer|undefined = undefined;
+
+        // Create Authorizer
+        if (this.requireAuthorizer) {
+            authorizer = new CreateAuthorizer(scope, this.appConfig, this.props.RESOURCES.AUTHORIZER!).JwtAuthorizer;   
+        }        
+
+        // Create Lambdas
+        const lambdaProp: TsgLambdaProps = {
+            scope,
+            prop: this.props,            
+            layers: this.layers,
+            appConfig: this.appConfig
+        };
+
+        const lambdas = new CreateLambda(lambdaProp, this.appConfig);
+
+        if (this.tables) {
+            this.AssignAccessToTables(this.tables, lambdas.Lambdas);
+        }        
+
+        // Allow access to existing tables
+        if (this.requireDynamoTableRefs) {
+            this.AssignAccessToTableRefs(scope, this.props.RESOURCES.DYNAMO?.TABLE_REFS, lambdas.Lambdas);
+        }
+
+        if (this.secretMgr) {
+            this.AssignAccessToSecretManager(this.secretMgr, lambdas.Lambdas);
+        }        
+
+        lambdas.Lambdas.map((lambda) => {
+            lambda.metricErrors({                
+                    label: `${lambda.functionName}-errors`, 
+                    period: Duration.minutes(3)           
+                
+            })
+        });
+
+        this.AddRoutes(this.props, this.gatewayApi, lambdas.Lambdas, authorizer);
+    }
+
+    private AssignAccessToTables(tables: Table[], lambdas: NodejsFunction[]) {
+
+        if (tables) {
+            tables.forEach((table: ITable) => {
+
+                lambdas.forEach((lambda: NodejsFunction) => {
+
+                    //  This is a CDK bug: It doesn't provide
+                    //  access to the indexes.
+                    //table.grantReadWriteData(lambda);
+
+                    //  Workaround:
+                    lambda.addToRolePolicy(
+                        new PolicyStatement({
+                            effect: Effect.ALLOW,
+                            actions: CreateDynamoDb.ReadWriteActions,
+                            resources: [
+                                table.tableArn,
+                                `${table.tableArn}/*`, // This is not recognized by cdk, but table is.  why?
+                            ],
+                        })
+                    );
+
+                    
+                    
+                });
+
+            });
+        }
+    }
+
+    private AssignAccessToTableRefs(scope: Construct, tableRefs: TsgDynamoTableRef[] | undefined, lambdas: NodejsFunction[]) {
+
+        if (tableRefs) {
+            tableRefs.forEach((tableRef: TsgDynamoTableRef) => {
+
+                if (tableRef.region) {
+                    this.AssignReadWriteAccessToTableInRegion(scope, tableRef, lambdas);
+                }
+                else {
+                    this.AssignReadWriteAccessToTable(scope, tableRef, lambdas);
+                }
+            });
+        }
+    }
+
+    private AssignReadWriteAccessToTableInRegion(scope: Construct, tableRef: TsgDynamoTableRef, lambdas: NodejsFunction[]) {
+        lambdas.forEach((lambda: NodejsFunction) => {
+
+            let tableArn = "arn:aws:dynamodb:" + tableRef.region + ":" + ((scope as Stack).account) + ":table/" + tableRef.tableName;
+            let statement = new PolicyStatement({
+                effect: Effect.ALLOW,
+                resources: [
+                    tableArn,
+                    tableArn + "/index/*",
+                ],
+                actions: CreateDynamoDb.ReadWriteActions,
+            });
+
+            lambda.role?.addToPrincipalPolicy(statement);
+            
+        });
+    }
+
+    private AssignReadWriteAccessToTable(scope: Construct, tableRef: TsgDynamoTableRef, lambdas: NodejsFunction[]) {
+        let table: ITable = Table.fromTableName(scope, tableRef.tableName, tableRef.tableName);
+
+        lambdas.forEach((lambda: NodejsFunction) => {
+            table.grantReadWriteData(lambda)
+            
+        });
+    }
+
+    private AddRoutes(props: MicroserviceProps, 
+        gateway: IRestApi, 
+        lambdas: NodejsFunction[], 
+        authorizer?: TokenAuthorizer) {
+
+        this.appConfig.lambdaConfigs?.forEach((prop: TsgLambdaProp) => {
+
+            const lambdaId = CreateLambda.getIdForLambda(prop);
+            const lambdaNode = lambdas.find(x => x.node.id === lambdaId);
+
+            if (!lambdaNode) {
+                throw new Error("Can't find the Lambda Integration");                
+            }
+
+            Routes.createResource(prop, gateway, lambdaNode, authorizer);
+        
+        });
+    }
+
+    private AssignAccessToSecretManager(secret: ISecret, lambdas: NodejsFunction[]) {
+
+        lambdas.forEach((lambda) => {
+            const result = secret.grantRead(lambda);
+            console.log('Assigning Access to Secret Manager: ',result);
+        });
+        
+    }
+
+}

package/src/resources/helpers/createAuthorizer.ts

@@ -0,0 +1,106 @@
+import { CfnOutput, Duration } from "aws-cdk-lib";
+import { IdentitySource, TokenAuthorizer } from "aws-cdk-lib/aws-apigateway";
+import { ManagedPolicy, ServicePrincipal } from "aws-cdk-lib/aws-iam";
+import { NodejsFunction, NodejsFunctionProps, SourceMapMode } from "aws-cdk-lib/aws-lambda-nodejs";
+import { Construct } from "constructs";
+import * as path from 'path';
+import { AppConfig } from "../../config/AppConfig";
+
+import { TsgLambdaProp } from "../../config/types";
+import { MicroserviceProps } from "../../interfaces/MicroserviceProps";
+import { BaseResource } from "../base/baseResource";
+import { CreateLambda } from "../lambda/createLambda";
+
+export class CreateAuthorizer extends BaseResource<TokenAuthorizer> {
+
+    get JwtAuthorizer() {
+        return this.createdResources[0];
+    }
+
+    constructor(scope: Construct, props: AppConfig, protected authProps: TsgLambdaProp) {
+
+        super(scope, props);
+
+        this.createdResources = this.createResource(scope)!;
+
+        if (this.createdResources) {
+            this.createOutput<TokenAuthorizer>(scope, this.createdResources);
+        }
+
+    }
+
+    protected createResource(scope: Construct): TokenAuthorizer[] | null {
+        return [this.createLambdaAuthorizer(scope, this.authProps)];
+    }
+
+    private createLambdaAuthorizer(scope: Construct, lambdaConfig: TsgLambdaProp) {
+        //console.log("ENTER createLambdaAuthorizer");
+
+        const authorizerProps = this.createLambdaFunctionProps(lambdaConfig!);
+
+        const lambdaId = CreateLambda.getIdForLambda(lambdaConfig);
+        const lambda = new NodejsFunction(scope, lambdaId, authorizerProps);
+
+        lambda.grantInvoke(new ServicePrincipal('apigateway.amazonaws.com'));
+
+        if (lambdaConfig?.managedPolicies && lambdaConfig.managedPolicies.length > 0) {
+            this.assignManagedPolicies(lambda, lambdaConfig.managedPolicies);
+        }
+
+        const lambdaAuthorizer = new TokenAuthorizer(scope, `${lambdaConfig.name}-authorizer`, {
+            handler: lambda,
+            authorizerName: lambdaConfig.name,
+            resultsCacheTtl: Duration.seconds(0), 
+            identitySource: IdentitySource.header('Authorization'),
+            
+        });
+
+        return lambdaAuthorizer;
+    }
+
+    protected createOutput<T>(scope: Construct, createdAssets: T[]): void {
+
+        const entity = createdAssets[0];
+
+        // new CfnOutput(scope, `authorizer`, {
+        //     value: (entity as TokenAuthorizer).authorizerArn
+        // });
+
+    }
+
+    private createLambdaFunctionProps(prop: TsgLambdaProp) {       
+
+        const lambdaProp: NodejsFunctionProps = {
+            entry: path.join(prop.codePath),
+            functionName: prop.name,
+            handler: prop.handler,
+            runtime: prop.runtime || this.config.GLOBALS.stackRuntime,
+            timeout: prop.duration || Duration.minutes(2),
+            memorySize: prop.memory || 512,
+            environment: {
+                "VERBOSE_LOGGING": "true",                
+                ...prop.environment
+            },
+            bundling: {
+                minify: false,
+                target: 'es2020',
+                sourceMap: true,
+                sourceMapMode: SourceMapMode.INLINE,
+                environment: prop.environment || prop.environment,
+            },
+        }
+        return lambdaProp;
+    };
+
+    private assignManagedPolicies(lambda: NodejsFunction, managedPolicyNames: string[]) {
+
+        managedPolicyNames.forEach((managedPolicyName: string) => {
+
+            let policy = ManagedPolicy.fromAwsManagedPolicyName(managedPolicyName);
+
+            lambda.role?.addManagedPolicy(policy);
+        });
+
+    }
+
+}

package/src/resources/helpers/createCommonLayer.ts

@@ -0,0 +1,18 @@
+import { Construct } from "constructs";
+import { createLambdaLayer } from "../lambda-layer/createLambdaLayer";
+import { TsgLambdaLayerProp } from "../../config/types/TsgLambdaLayerProp";
+import { AppConfig } from "../../config/AppConfig";
+
+export const createCommonLayer = (scope: Construct, appProps: AppConfig) => {
+
+    const prop: TsgLambdaLayerProp = {
+        description: 'Common Lambda layer',
+        codePath: './node_modules/@davissylvester/bishop-cdk-constructs/dist',
+        name: 'bishop-common-layer'
+    };  
+    
+    const layer = createLambdaLayer(scope, appProps, prop)
+    
+    return layer;
+};
+

package/src/resources/helpers/createRoutes.ts

@@ -0,0 +1,43 @@
+import { IRestApi, LambdaIntegration, Resource, TokenAuthorizer } from "aws-cdk-lib/aws-apigateway";
+import { NodejsFunction } from "aws-cdk-lib/aws-lambda-nodejs";
+import { TsgLambdaProp } from "../../config/types";
+
+
+export class Routes {
+
+    public static Resources: Resource[] = [];  
+    private static routeMap = new Map();       
+
+    public static createResource(        
+        prop: TsgLambdaProp, 
+        api: IRestApi, 
+        lambdaNode: NodejsFunction, 
+        authorizer?: TokenAuthorizer) {
+
+        const routeMap: Map<string, Resource> = new Map();
+
+        //  Only attach lambda to an Api Gateway if a route exist
+        if (prop.apiGateway?.route) {
+
+        //  Note:  this now uses the bundle version as the first segment in the path.
+        let activeRoutePath = `/${(prop.apiGateway.version) ? prop.apiGateway.version : 1 }`;
+        let activeResource: Resource = Routes.routeMap.get(activeRoutePath) ||  api.root.addResource(activeRoutePath);
+        Routes.routeMap.set(activeRoutePath, activeResource);
+
+        //  Now we go through our route segments creating the rest of the path.
+        const pathSegments = prop.apiGateway?.route.split("/").filter(x => (x));
+        for (let i = 0; i < pathSegments.length; i++) {
+            activeRoutePath = `${activeRoutePath}/${pathSegments[i]}`;
+            let secondaryResource = Routes.routeMap.get(activeRoutePath) || activeResource!.addResource(pathSegments[i]);                
+            Routes.routeMap.set(activeRoutePath, secondaryResource);                                  
+            activeResource = secondaryResource;                
+        }
+        
+        //  Finally, we attach our function to the last resource
+        activeResource.addMethod(prop.apiGateway.method || 'GET',
+            new LambdaIntegration(lambdaNode, { proxy: true, }), 
+            prop.apiGateway.secure ? { authorizer } : undefined);    
+    }
+}
+
+}

package/src/resources/lambda/createLambda.ts

@@ -0,0 +1,184 @@
+import { CfnOutput, Duration } from "aws-cdk-lib";
+import { TokenAuthorizer } from "aws-cdk-lib/aws-apigateway";
+import { Alarm, ComparisonOperator, IAlarmAction } from "aws-cdk-lib/aws-cloudwatch";
+import { IRole, ManagedPolicy } from "aws-cdk-lib/aws-iam";
+import { LayerVersion } from "aws-cdk-lib/aws-lambda";
+import { NodejsFunction, NodejsFunctionProps, SourceMapMode } from "aws-cdk-lib/aws-lambda-nodejs";
+import { Construct } from "constructs";
+import * as path from 'path';
+import { AppConfig } from "../../config/AppConfig";
+import { TsgLambdaProp } from "../../config/types";
+
+import { TsgLambdaProps } from "../../config/types/TsgLambdaProps";
+import { CreateLambdaFunctionInput } from "../../interfaces/CreateLambdaFunctionInput";
+import { BaseResource } from "../base/baseResource";
+
+
+export class CreateLambda extends BaseResource<NodejsFunction> {
+
+    public Lambdas: NodejsFunction[] = [];
+    
+
+    constructor(private props: TsgLambdaProps, config: AppConfig) {
+        super(props.scope, config);
+
+        const resources = this.createResource(props.scope);
+
+        this.Lambdas = [...resources];
+
+        this.createAlarmsForLambdas(this.Lambdas);
+        
+        this.createOutput(props.scope, resources);
+    }
+
+    protected createResource(scope: Construct): NodejsFunction[] {
+
+        const result = this.createLambdas(this.props);
+        
+        return result;
+    }
+
+    protected createOutput<T>(scope: Construct, createdAssets: T[]): void {
+        createdAssets.forEach((x, idx) => {
+
+            new CfnOutput(scope, `lambda-${idx}`, {
+                // @ts-ignore
+                value: x.functionName
+            });
+        });
+    }
+
+    private createLambdas(props: TsgLambdaProps): NodejsFunction[] {
+        
+        const createdLambdas: NodejsFunction[] = this.createLambdaFunctions(this.scope, props.role, props.layers);
+
+        return createdLambdas;
+    }
+
+    private createLambdaFunctions(scope: Construct, role?: IRole, layers?: LayerVersion[]) {
+
+        //console.log("ENTER createLambdaFunctions");
+        const createdLambdas = this.props.prop.RESOURCES.LAMBDA.map((config:TsgLambdaProp) => {
+
+            //console.log("ENTER createLambdaFunctions.map for " + config.name);
+            let lambdaProps = this.createLambdaProps(config, role, layers);
+
+            const lambdaId = CreateLambda.getIdForLambda(config);
+            let fctn = new NodejsFunction(scope, lambdaId, lambdaProps);
+
+            //  If we have managed policies, we add them.
+            if (config.managedPolicies && config.managedPolicies?.length > 0) {
+                
+                this.assignManagedPolicies(fctn, config.managedPolicies);
+            }
+
+            return fctn;
+        });
+
+        return createdLambdas || [];
+    }
+
+    private createLambdaProps(prop: TsgLambdaProp, role?: IRole, layers?: LayerVersion[], props?: TsgLambdaProps) {
+
+        return this.createLambdaFunctionProps({
+            prop, 
+            role,
+            layers, 
+            props
+        });
+    }
+
+    private createLambdaFunctionProps(props: CreateLambdaFunctionInput) {
+        const { prop, role, layers } = props;
+
+        const lambdaProp: NodejsFunctionProps = {
+            entry: path.join(prop.codePath),
+            functionName: `${this.props.appConfig.AppPrefix}-${prop.name}`,
+            handler: prop.handler,
+            runtime: prop.runtime || this.config.GLOBALS.stackRuntime,
+            timeout: prop.duration || Duration.minutes(2),
+            memorySize: prop.memory || 512,
+            environment: {
+                "VERBOSE_LOGGING": "true",                
+                ...prop.environment
+            },
+            bundling: {
+                minify: false,
+                target: 'es2020',
+                sourceMap: true,
+                sourceMapMode: SourceMapMode.INLINE,
+                environment: prop.environment || prop.environment,
+            },
+            role,
+            layers
+
+        }
+
+        
+        return lambdaProp;
+    };
+
+    private assignManagedPolicies(lambda: NodejsFunction, managedPolicyNames: string[]) {
+
+        managedPolicyNames.forEach((managedPolicyName: string) => {
+
+            let policy = ManagedPolicy.fromAwsManagedPolicyName(managedPolicyName);
+
+            lambda.role?.addManagedPolicy(policy);
+        });
+
+    }
+
+    private createAlarmsForLambdas(lambdas: NodejsFunction[]) {        
+
+        lambdas.forEach((lambda, idx) => {
+
+            const errorMetric = lambda.metricErrors({
+                period: Duration.minutes(3),
+                
+            });
+
+            const durationMetric = lambda.metricDuration({
+                period: Duration.minutes(3),                
+            });
+
+            const invocationMetric = lambda.metricInvocations({
+                period: Duration.minutes(3),                
+            });
+
+            new Alarm(this.props.scope, `${this.config.AppPrefix}-${idx}-error-alarm`, {
+                metric: errorMetric, 
+                threshold: 5,
+                comparisonOperator: ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+                evaluationPeriods: 3,
+                alarmDescription: `${this.config.AppPrefix}-${idx} errors over 3 min period`,
+                alarmName: `${this.config.AppPrefix}-${idx}-error-alarm`
+            });
+
+            new Alarm(this.props.scope, `${this.config.AppPrefix}-${idx}-duration-alarm`, {
+                metric: durationMetric, 
+                threshold: 1,
+                comparisonOperator: ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+                evaluationPeriods: 3,
+                alarmDescription: `${this.config.AppPrefix}-${idx} duration errors over 3 min period`,
+                alarmName: `${this.config.AppPrefix}-${idx}-duration-alarm`
+            });
+
+            const invocationAlarm = new Alarm(this.props.scope, `${this.config.AppPrefix}-${idx}-invocation-alarm`, {
+                metric: errorMetric, 
+                threshold: 1000,
+                comparisonOperator: ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+                evaluationPeriods: 3,
+                alarmDescription: `${this.config.AppPrefix}-${idx} errors over 3 min period`,
+                alarmName: `${this.config.AppPrefix}-${idx}-invocation-Metric-alarm`
+            });
+
+            // const alarmAction: IAlarmAction = {};
+            // invocationAlarm.addAlarmAction(alarmAction);
+        });
+    }
+
+    public static getIdForLambda(lambdaProp: TsgLambdaProp) {       
+        return `${lambdaProp.name}`.toLowerCase();
+    }
+}

package/src/resources/lambda-layer/createLambdaLayer.ts

@@ -0,0 +1,40 @@
+import { Code, LayerVersion, LayerVersionProps, Runtime } from "aws-cdk-lib/aws-lambda";
+import { Construct } from "constructs";
+import { TsgLambdaLayerProp } from "../../config/types/TsgLambdaLayerProp";
+import { MicroserviceProps } from "../../interfaces/MicroserviceProps";
+import * as path from "path";
+
+export const createLambdaLayer = (scope: Construct, globalProps: MicroserviceProps, prop: TsgLambdaLayerProp) => {
+
+    const propResult = createLambdaLayerProps(prop, globalProps);
+
+    const layer = new LayerVersion(scope, `${globalProps.GLOBALS.name}-common-layer`, propResult);
+
+    return layer;
+
+};
+
+const createLambdaLayerProps = (prop: TsgLambdaLayerProp, props: MicroserviceProps) => {
+
+    const baseProps = baseLayerProps(props, prop.description);
+
+    const baseLayer: LayerVersionProps = {
+        ...baseProps,
+        code: Code.fromAsset(path.join(prop.codePath),),
+        description: prop.description,
+        layerVersionName: `${prop.name}`
+    };
+    return baseLayer;
+};
+
+const baseLayerProps = (prop: MicroserviceProps, desc: string) => {
+
+    const baseLayerProps: LayerVersionProps = {
+        code: Code.fromAsset(path.join(''),),
+        compatibleRuntimes: [prop.GLOBALS.stackRuntime],
+        license: 'Apache-2.0',
+        description: desc,
+    };
+
+    return baseLayerProps;
+};

package/src/resources/layers/common/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@davissylvester/bishop-common",
+  "version": "1.0.0",
+  "description": "Common Layers for Lambdas",
+  "main": "index.js",
+  "scripts": {
+    "test": "jest && exit 1"
+  },
+  "keywords": [],
+  "author": "Davis Sylvester <Davis@sylvesterllc.com>",
+  "license": "ISC",
+  "dependencies": {
+    "@aws-sdk/client-dynamodb": "^3.137.0",
+    "@aws-sdk/lib-dynamodb": "^3.145.0",
+    "@aws-sdk/util-dynamodb": "^3.137.0",   
+    "luxon": "^3.0.4",
+    "uuidv4": "^6.2.13"
+  },
+  "devDependencies": {
+    "@types/aws-lambda": "^8.10.111"
+  }
+}

package/src/resources/layers/common/src/nodejs/api-response/index.ts

@@ -0,0 +1 @@
+export * from "./responses";

package/src/resources/layers/common/src/nodejs/api-response/responses.ts

@@ -0,0 +1,41 @@
+export const badResponse = (errorMessage: string) => {
+    return {
+        statusCode: 400,
+        body: JSON.stringify({
+            message: errorMessage
+        }),
+        headers: {
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Credentials": true,
+        },
+    };
+
+};
+
+export const okResponse = (data: Object) => {
+    return {
+        statusCode: 200,
+        body: JSON.stringify({
+            data
+        }),
+        headers: {
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Credentials": true,
+        },
+    };
+
+};
+
+export const unauthorizedResponse = (data: object) => {
+    return {
+        statusCode: 401,
+        body: JSON.stringify({
+            data
+        }),
+        headers: {
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Credentials": true,
+        },
+    };
+
+};

package/src/resources/layers/common/src/nodejs/index.ts

@@ -0,0 +1,3 @@
+export * from "./logger/index";
+export * from "./api-response/index";
+

package/src/resources/layers/common/src/nodejs/logger/IContext.ts

@@ -0,0 +1,7 @@
+export interface ILoggerContext {
+
+    functionName?: string;
+    name: string;
+    message: string;
+
+}

package/src/resources/layers/common/src/nodejs/logger/index.ts

@@ -0,0 +1,2 @@
+export * from "./IContext";
+export * from "./logger";

package/src/resources/layers/common/src/nodejs/logger/logger.ts

@@ -0,0 +1,11 @@
+import { ILoggerContext } from "./IContext";
+
+export function logger(context: ILoggerContext) {
+
+    const showLogs = Boolean(process.env.VERBOSE_LOGGING || false);
+
+    if (showLogs) {
+        console.log(`### ${(context.functionName) ? `${context.functionName} ::  ` : ''} ${(context.name) ? `${context.name} ::  ` : ''}  ${(context.message) ? `${context.message} ::  ` : ''}`);
+    }
+    // ### run() :: 
+}

package/src/resources/layers/common/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist/nodejs/node_modules/@davissylvester/bishop-common",
+    "skipLibCheck": true
+  }
+}