@sylvesterllc/aws-constructs 1.0.0

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@sylvesterllc/aws-constructs",
+  "version": "1.0.0",
+  "description": "AWS Constructs",
+  "main": "index.js",
+  "scripts": {
+    "build": "npm run clean && tsc",
+    "build:layers": "cd ./src/resources/layers/common && pnpm i && tsc",
+    "watch": "tsc -w",
+    "test": "jest",
+    "cdk": "cdk",
+    "clean": "rm -rf dist",
+    "clean:layers": "rm -rf ./src/resources/layers/common/dist",
+    "publish:lib": "npm run build && npm publish",
+    "preinstall": "npx only-allow pnpm"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DavisSylvester/aws-constructs.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Davis Sylvester <davis@sylvesterllc.com>",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/DavisSylvester/aws-constructs/issues"
+  },
+  "homepage": "https://github.com/DavisSylvester/aws-constructs#readme",
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/luxon": "^3.2.0",
+    "@types/node": "^18.15.3",
+    "jest": "^29.5.0",
+    "ts-jest": "^29.0.5",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.2"
+  },
+  "dependencies": {
+    
+    "aws-cdk-lib": "^2.69.0",
+    "constructs": "^10.1.280",
+    "dotenv": "^16.0.3",
+    "fsbin": "^1.0.11",
+    "luxon": "^3.3.0",
+    "source-map-support": "^0.5.21"
+  }
+}

package/readme.md

@@ -0,0 +1,147 @@
+# Bishop CDK Construct Library
+
+## Bishop Constructs <a name="Constructs" id="Constructs"></a>
+
+Bishop Constructs is a construct library for creating new AWS Infrastructure in a standardize
+reusable manner. 
+
+[![Publish package to GitHub Packages](https://github.com/DavisSylvester/aws-constructs/actions/workflows/publish.yaml/badge.svg?branch=main)](https://github.com/DavisSylvester/aws-constructs/actions/workflows/publish.yaml)
+
+### Available Constructors
+
+ - [Microservice](#microservice-construct)
+
+And more...
+
+## Installation
+
+1. Install the npm package:
+
+    `npm install @davissylvester/bishop-cdk-constructs --save`
+    - *ensure you have a `.npmrc` that uses the @sylvesterllc npm registry*
+
+
+
+# Microservice Construct
+The Microservice construct provides and easy way to get started with a basic Microservice.
+
+#### Infrastructure
+    - API Gateway (Rest API)
+    - Lambda 
+    - Dynamodb
+    - Lambda Authorizer 
+      - TokenAuthorizer
+
+#### Access 
+*All lambdas are created with Read/Write Access to DynamoDB tables*
+
+### Usage
+```typescript
+import { MicroService, MicroserviceProps } from '@davissylvester/bishop-cdk-constructs';
+
+new MicroService(this, 'microservice-test', microServiceProps);
+```
+
+ ## MicroserviceProps
+
+ ```json
+ const microServiceProps: MicroserviceProps = {
+      GLOBALS: {
+          name: `sample-test-app`,
+          environments: "dev",
+          stackRuntime: Runtime.NODEJS_18_X,          
+      },
+      API: {
+          Name: `sample-test-app`,
+          Description: 'This is my new API'
+      },
+      RESOURCES: {
+          AUTHORIZER: {
+            name: `jwt-authorizer`,
+            codePath: './lambda-functions/authorizer/index.ts',
+            handler: 'handler',
+            apiPathRoot: '',
+            route: '',
+        }, 
+          LAMBDA: [
+              {
+                  name: `hello-world`,
+                  codePath: './lambda-functions/hello-world/index.ts',
+                  handler: 'main',
+                  method: 'get',
+                  apiPathRoot: 'hello-world',
+                  route: '/hello-world'
+              },
+              {
+                  name: `hellow-world2`,
+                  codePath: './lambda-functions/hello-world/index.ts',
+                  handler: 'main',
+                  method: 'get',
+                  apiPathRoot: '/hello-world/2',
+                  route: '/hello-world/2'
+              },
+              {
+                name: `hello-world3`,
+                codePath: './lambda-functions/hello-world/index.ts',
+                handler: 'main',
+                method: 'get',
+                apiPathRoot: '/hello-world/2',
+                route: '/hello-world/2/{id}',
+                secure: true
+            },
+          ],
+          DYNAMO: {
+              TABLES: [
+                  {
+                      tableName: `sample-audit-history`,
+                      primaryKey: {
+                          name: 'id',
+                          type: AttributeType.STRING,
+                      },
+                      billingMode: BillingMode.PAY_PER_REQUEST,
+                      indexes: [
+                          {
+                              indexName: 'createdTS',
+                              partitionKey: {
+                                  name: 'createdTS',
+                                  type: AttributeType.NUMBER
+                              },
+                              projectionType: ProjectionType.ALL
+                          },
+                          {
+                              indexName: 'username',
+                              partitionKey: {
+                                  name: 'username',
+                                  type: AttributeType.STRING
+                              },
+                              projectionType: ProjectionType.ALL
+                          },
+                      ]
+                  },
+              ],
+          },
+  
+      }
+  }; 
+ ```
+
+
+## Best Practice
+When using this library it is a good practice to start with a new CDK project
+   
+   - `npm install -g typescript aws-cdk`
+   - `mkdir my-new-project`
+   - `cd my-new-project`
+   - `cdk init app --language typescript`
+   - `npm i @davissylvester/bishop-cdk-constructs`
+   - `mkdir lambda-functions` (*holds all your lambda code*)
+
+# [Demo Project](https://github.com/davissylvester/bishop-cdk-constructs-demo.git)
+
+- Clone the repository
+  - `git clone https://github.com/davissylvester/bishop-cdk-constructs-demo.git`
+  - `npm i`
+  - `cdk bootstrap`
+  - `cdk deploy`
+
+

package/src/config/AppConfig.ts

@@ -0,0 +1,93 @@
+import { config } from "process";
+import { ApiAppConfig } from "./customConfigs/ApiAppConfig";
+import { GlobalAppConfig } from "./customConfigs/GlobalAppConfig";
+import { IAppConfig } from "./customConfigs/IAppConfig";
+import { ResourceAppConfig } from "./customConfigs/ResourceAppConfig";
+import { TsgDynamoProp } from "./types";
+import { TsgDnsAppConfig } from "./types/TsgDnsConfig";
+import { TsgLambdaName } from "./types/TsgLambdaName";
+import { TsgLambdaProp } from "./types/TsgLambdaProp";
+
+export class AppConfig implements IAppConfig {
+
+    public API: ApiAppConfig;
+    public GLOBALS: GlobalAppConfig;
+    public RESOURCES: ResourceAppConfig;
+    public DNS: TsgDnsAppConfig;
+
+
+    public lambdaConfigs: TsgLambdaProp[];
+    public dynamoConfigs: TsgDynamoProp[];
+
+    get AppName() {
+        return this.GLOBALS.name;
+    }
+
+    get AppPrefix() {
+        return (this.GLOBALS.prefix) ? this.GLOBALS.prefix : this.GLOBALS.name;
+    }
+
+    constructor(config: IAppConfig) {
+        this.populate(config);
+    }
+
+    private populate(config: IAppConfig) {
+        this.populateGlobalConfig(config);
+        this.populateApiConfig(config);
+        this.populateResources(config);
+
+
+    }
+
+    private populateGlobalConfig(config: IAppConfig) {
+        this.GLOBALS = {
+            ...config.GLOBALS
+        };
+    }
+
+    private populateApiConfig(config: IAppConfig) {
+
+        if (config.API)
+            this.API = {
+                ...config.API
+            };
+    }
+
+    private populateResources(config: IAppConfig) {
+        this.RESOURCES = {
+            ...config.RESOURCES
+        };
+        this.RESOURCES.DYNAMO = {
+            ...config.RESOURCES.DYNAMO
+        };
+
+        this.DNS = {
+            ...config.DNS
+        };
+    }
+    //     this.lambdaConfigs = this.expandProps<TsgLambdaName, TsgLambdaProp>(this.RESOURCES.LAMBDA!);
+    //     this.dynamoConfigs = this.expandProps<TsgTableName, TsgDynamoProp>(this.RESOURCES.DYNAMO?.TABLES!);
+    // }
+
+    private populateConfigs<T, R>(result: R[], record?: Record<string, R>) {
+
+        if (!record) {
+            return null;
+        }
+
+        result = this.expandProps<T, R>(record);
+        return result;
+
+    }
+
+    private expandProps<T, R>(data: Record<string, R>) {
+
+        console.log('data', data);
+        const result = [];
+        // @ts-ignore
+        for (const [key, value] of Object.entries(data)) {
+            result.push(value);
+        }
+        return result as R[];
+    }
+}

package/src/config/Constants.ts

@@ -0,0 +1,27 @@
+export const CONSTANTS = {
+
+    DYNAMODB: {
+        TABLES: {
+            AUTH_HISTORY_TABLE: {
+                name: 'auth-history',
+                indexes: {
+                    AuthHistoryTS: {
+                        name: 'auth-history-ts'
+                    },
+                    Username: {
+                        name: 'username',
+                    }
+                }
+            }
+        },
+    },
+    WEB: {
+        ADMIN_PORTAL_BUCKET: 'bishop.davissylvester.net',
+    },
+    AUTH:{
+        OAUTH: {
+            CLIENT_ID: process.env.AMAZON_OAUTH_CLIENT_ID,
+            CLIENT_SECRET: process.env.AMAZON_OAUTH_CLIENT_SECRET
+        }
+    }
+};

package/src/config/Environments.ts

@@ -0,0 +1,2 @@
+export type Environment = "dev" | "qa" | "prod";
+export type ClientAppType = "mobile" | "web";

package/src/config/MicroserviceAppConfig.ts

@@ -0,0 +1,9 @@
+import { MicroserviceProps } from "../interfaces/MicroserviceProps";
+import { AppConfig } from "./AppConfig";
+
+export class MicroServiceAppConfig extends AppConfig {
+
+   constructor(config: MicroserviceProps) {
+       super(config);
+   }
+}

package/src/config/bishopConfig.ts

@@ -0,0 +1,83 @@
+import { AttributeType, BillingMode, ProjectionType } from "aws-cdk-lib/aws-dynamodb";
+import { Runtime } from "aws-cdk-lib/aws-lambda";
+import { CONSTANTS } from "./Constants";
+import { IAppConfig } from "./customConfigs/IAppConfig";
+
+export const config: IAppConfig = {
+    GLOBALS: {
+        name: `${process.env.APP_NAME}`,        
+        accountNumber: process.env.CDK_DEFAULT_ACCOUNT || "",
+        region: process.env.CDK_DEFAULT_REGION || "us-east-1",
+        stackRuntime: Runtime.NODEJS_18_X,
+    },
+    API: {
+        Name: `${process.env.APP_NAME}-auth-api`,
+        Description: 'This is my new API',
+        DomainPrefix: 'my-custom-api'
+    },
+    RESOURCES: {        
+                LAMBDA: [
+                    {
+                        name: `create-account`,
+                        codePath: './lambda-functions/auth/createAccount.ts',
+                        handler: 'main',                                                
+                        apiGateway: {
+                            route: '/account/create-account',
+                            method: 'post',
+                        },
+                        
+                    },
+                    {
+                        name: `change-password`,
+                        codePath: './lambda-functions/auth/changePassword.ts',
+                        handler: 'main',                                               
+                        apiGateway: {
+                            route: '/account/change-password',
+                            method: 'post', 
+                        }
+                    },                    
+                ],
+            
+        DYNAMO: {
+            TABLES: [
+                {
+                    tableName: `${CONSTANTS.DYNAMODB.TABLES.AUTH_HISTORY_TABLE.name}`,
+                    primaryKey: {
+                        name: 'id',
+                        type: AttributeType.STRING,
+                    },
+                    billingMode: BillingMode.PAY_PER_REQUEST,
+                    indexes: [
+                        {
+                            indexName: CONSTANTS.DYNAMODB.TABLES.AUTH_HISTORY_TABLE.indexes.AuthHistoryTS.name,
+                            partitionKey: {
+                                name: 'createdTS',
+                                type: AttributeType.NUMBER
+                            },
+                            projectionType: ProjectionType.ALL
+                        },
+                        {
+                            indexName: CONSTANTS.DYNAMODB.TABLES.AUTH_HISTORY_TABLE.indexes.Username.name,
+                            partitionKey: {
+                                name: 'username',
+                                type: AttributeType.STRING
+                            },
+                            projectionType: ProjectionType.ALL
+                        },
+                    ]
+                },            
+        ],
+        },
+    
+    },
+    DNS: {
+       ZoneName:  '',
+       ZoneId: '',
+       ZoneNameWithoutPeriod: 'not-used',
+       ZoneNameWithoutSuffix: 'not-used',
+       ZoneExist: true,
+       HostName: '',
+       FQDN: ''
+        
+    }
+}; 

package/src/config/customConfigs/ApiAppConfig.ts

@@ -0,0 +1,6 @@
+export interface ApiAppConfig {
+
+    Name: string;
+    Description: string;
+    DomainPrefix?: string;
+};

package/src/config/customConfigs/GlobalAppConfig.ts

@@ -0,0 +1,11 @@
+import { Runtime } from "aws-cdk-lib/aws-lambda";
+import { Environment } from "../Environments";
+export interface GlobalAppConfig {
+
+    
+    name: string;
+    accountNumber: string;
+    region: string;
+    stackRuntime: Runtime;
+    prefix?: string;     
+}

package/src/config/customConfigs/IAppConfig.ts

@@ -0,0 +1,13 @@
+import { Environment } from "../Environments";
+import { TsgDnsAppConfig } from "../types/TsgDnsConfig";
+import { ApiAppConfig } from "./ApiAppConfig";
+import { GlobalAppConfig } from "./GlobalAppConfig";
+import { ResourceAppConfig } from "./ResourceAppConfig";
+
+export interface IAppConfig {
+    
+    GLOBALS: GlobalAppConfig;
+    API?: ApiAppConfig;
+    RESOURCES: ResourceAppConfig;
+    DNS: TsgDnsAppConfig;
+}

package/src/config/customConfigs/ResourceAppConfig.ts

@@ -0,0 +1,12 @@
+import {
+    TsgDynamoDbProp,
+    TsgLambdaProp,
+} from "../types";
+import { TsgLambdaLayerProp } from "../types/TsgLambdaLayerProp";
+
+export interface ResourceAppConfig {    
+    DYNAMO?: TsgDynamoDbProp;
+    LAMBDA_LAYERS?: TsgLambdaLayerProp[];
+    AUTHORIZER?: TsgLambdaProp;
+    LAMBDA: TsgLambdaProp[];
+}

package/src/config/microServiceConfig.ts

@@ -0,0 +1,85 @@
+import { AttributeType, BillingMode, ProjectionType } from "aws-cdk-lib/aws-dynamodb";
+import { Runtime } from "aws-cdk-lib/aws-lambda";
+import { CONSTANTS } from "./Constants";
+import { IAppConfig } from "./customConfigs/IAppConfig";
+
+export const config: IAppConfig = {
+    GLOBALS: {
+        name: `${process.env.APP_NAME}`,
+        accountNumber: process.env.CDK_DEFAULT_ACCOUNT || "",
+        region: process.env.CDK_DEFAULT_REGION || "us-east-1",
+        stackRuntime: Runtime.NODEJS_18_X,
+    },
+    API: {
+        Name: `${process.env.APP_NAME}-auth-api`,
+        Description: 'This is my new API',
+        DomainPrefix: 'my-custom-api'
+    },
+    RESOURCES: {
+        LAMBDA: [
+            {
+                name: `create-account`,
+                codePath: './lambda-functions/auth/createAccount.ts',
+                handler: 'main',
+                apiGateway: {
+                    route: '/account/create-account',
+                    method: 'post',                    
+                },
+
+            },
+            {
+                name: `change-password`,
+                codePath: './lambda-functions/auth/changePassword.ts',
+                handler: 'main',
+                apiGateway: {
+                    route: '/account/change-password',
+                    method: 'post',
+                    version: 2
+                }
+            },
+        ],
+
+
+        DYNAMO: {
+            TABLES: [
+                {
+                    tableName: `${CONSTANTS.DYNAMODB.TABLES.AUTH_HISTORY_TABLE.name}`,
+                    primaryKey: {
+                        name: 'id',
+                        type: AttributeType.STRING,
+                    },
+                    billingMode: BillingMode.PAY_PER_REQUEST,
+                    indexes: [
+                        {
+                            indexName: CONSTANTS.DYNAMODB.TABLES.AUTH_HISTORY_TABLE.indexes.AuthHistoryTS.name,
+                            partitionKey: {
+                                name: 'createdTS',
+                                type: AttributeType.NUMBER
+                            },
+                            projectionType: ProjectionType.ALL
+                        },
+                        {
+                            indexName: CONSTANTS.DYNAMODB.TABLES.AUTH_HISTORY_TABLE.indexes.Username.name,
+                            partitionKey: {
+                                name: 'username',
+                                type: AttributeType.STRING
+                            },
+                            projectionType: ProjectionType.ALL
+                        },
+                    ]
+                },
+            ],
+        },
+
+    },
+    DNS: {
+        ZoneName: '',
+        ZoneId: '',
+        ZoneNameWithoutPeriod: 'not-used',
+        ZoneNameWithoutSuffix: 'not-used',
+        ZoneExist: true,
+        HostName: '',
+        FQDN: ''
+
+    }
+}; 

package/src/config/types/TsgCdkConfigType.ts

@@ -0,0 +1,3 @@
+export type TsgCdkConfigType<T> = {
+    [name: string]: T;    
+}

package/src/config/types/TsgCognitoConfig.ts

@@ -0,0 +1,6 @@
+export interface TsgCognitoConfig {
+
+    USER_POOL_ID: string;
+    CLIENT_ID: string;
+    POOL_ARN: string;
+}

package/src/config/types/TsgDnsConfig.ts

@@ -0,0 +1,9 @@
+export interface TsgDnsAppConfig {
+    ZoneName: string;
+    ZoneNameWithoutSuffix: string;
+    ZoneNameWithoutPeriod: string;
+    HostName: string;
+    FQDN: string;
+    ZoneExist: boolean;
+    ZoneId?: string;
+}

package/src/config/types/TsgDynamoDbProp.ts

@@ -0,0 +1,7 @@
+import { TsgDynamoProp } from "./TsgDynamoProp";
+import { TsgDynamoTableRef } from "./TsgDynamoTableRef";
+
+export interface TsgDynamoDbProp {
+    TABLE_REFS?: TsgDynamoTableRef[];
+    TABLES?: TsgDynamoProp[];
+}

package/src/config/types/TsgDynamoIndex.ts

@@ -0,0 +1,16 @@
+import { AttributeType, ProjectionType } from "aws-cdk-lib/aws-dynamodb";
+
+export interface TsgDynamoIndex {
+
+    indexName: string;
+    partitionKey: {
+        name: string;
+        type: AttributeType
+    },
+    sortKey?: {
+        name: string;
+        type: AttributeType
+    } 
+    projectionType: ProjectionType;
+
+}

package/src/config/types/TsgDynamoProp.ts

@@ -0,0 +1,17 @@
+import { AttributeType, BillingMode } from "aws-cdk-lib/aws-dynamodb";
+import { TsgDynamoIndex } from "./TsgDynamoIndex";
+
+export interface TsgDynamoProp {
+
+    tableName: string;
+    primaryKey: {
+        name: string;
+        type: AttributeType;
+    },
+    sortKey?: {
+        name: string;
+        type: AttributeType;
+    },
+    billingMode: BillingMode;
+    indexes: TsgDynamoIndex[],
+}

package/src/config/types/TsgDynamoTable.ts

@@ -0,0 +1,5 @@
+import { TsgDynamoProp } from "./TsgDynamoProp";
+
+export type TsgDynamoTable = {
+    [name: string]: TsgDynamoProp;    
+}

package/src/config/types/TsgDynamoTableRef.ts

@@ -0,0 +1,4 @@
+export type TsgDynamoTableRef = {
+    tableName: string;
+    region?: string;    
+}

package/src/config/types/TsgLambda.ts

@@ -0,0 +1,6 @@
+import { TsgLambdaProp } from "./TsgLambdaProp";
+
+export type TsgLambda = {    
+        [name: string]: TsgLambdaProp;
+    
+}

package/src/config/types/TsgLambdaLayerProp.ts

@@ -0,0 +1,5 @@
+export interface TsgLambdaLayerProp {
+    name: string;    
+    codePath: string;
+    description: string;
+}

package/src/config/types/TsgLambdaMap.ts

@@ -0,0 +1,4 @@
+import { NodejsFunction } from "aws-cdk-lib/aws-lambda-nodejs";
+import { TsgLambdaNode } from "./TsgLambdaNode";
+
+export type TsgLambdaMap = [NodejsFunction[], Map<string, TsgLambdaNode>]

package/src/config/types/TsgLambdaName.ts

@@ -0,0 +1,4 @@
+// DO NOT FORGET TO UPDATE TsgLambdaNameHelper 
+// WITH NEW LAMBDA NAMES
+export type TsgLambdaName = 'create-account' | 'verify-code' | 'change-password' | 'check-login' |
+ 'get-users' | 'resend-confirmation-code';

package/src/config/types/TsgLambdaNode.ts

@@ -0,0 +1,4 @@
+import { NodejsFunction, NodejsFunctionProps } from "aws-cdk-lib/aws-lambda-nodejs";
+import { TsgLambdaProp } from "./TsgLambdaProp";
+
+export type TsgLambdaNode = [TsgLambdaProp, NodejsFunction, NodejsFunctionProps];

package/src/config/types/TsgLambdaProp.ts

@@ -0,0 +1,16 @@
+import { Duration } from "aws-cdk-lib";
+import { Runtime } from "aws-cdk-lib/aws-lambda";
+import { TsgLambdaRoutable } from "./TsgLambdaRoutable";
+
+export interface TsgLambdaProp {
+
+    name: string;
+    codePath: string;
+    handler: string;
+    duration?: Duration;
+    environment?: { [name: string]: string };
+    runtime?: Runtime;
+    memory?: number;    
+    apiGateway?: TsgLambdaRoutable;
+    managedPolicies?: string[];
+}