@sylvesterllc/aws-constructs 1.0.0

package/src/config/types/TsgLambdaProps.ts

@@ -0,0 +1,19 @@
+import { IUserPool } from "aws-cdk-lib/aws-cognito";
+import { IRole } from "aws-cdk-lib/aws-iam";
+import { LayerVersion } from "aws-cdk-lib/aws-lambda";
+import { Construct } from "constructs";
+import { MicroserviceProps } from "../../interfaces/MicroserviceProps";
+import { TsgCognitoConfig } from "./TsgCognitoConfig";
+import { AppConfig } from "../AppConfig";
+
+export interface TsgLambdaProps {
+
+    scope: Construct;
+    prop: MicroserviceProps;
+    appConfig: AppConfig;
+    role?: IRole;
+    poolArn?: IUserPool;
+    layers?: LayerVersion[];
+    tsgCognito?: TsgCognitoConfig;
+    
+}

package/src/config/types/TsgLambdaRoutable.ts

@@ -0,0 +1,6 @@
+export interface TsgLambdaRoutable {
+    route: string;
+    secure?: boolean;
+    method?: "get" | "post" | "delete" | "put" | "patch";
+    version?: number;
+}

package/src/config/types/index.ts

@@ -0,0 +1,9 @@
+export * from "./TsgLambdaProp";
+export * from "./TsgCognitoConfig";
+export * from "./TsgLambdaMap";
+export * from "./TsgLambdaName";
+export * from "./TsgLambdaNode";
+export * from "./TsgDynamoProp";
+export * from "./TsgDynamoTableRef";
+export * from "./TsgDynamoDbProp";
+

package/src/constructs/MicroService.ts

@@ -0,0 +1,68 @@
+import { Table } from "aws-cdk-lib/aws-dynamodb";
+import { Construct } from "constructs";
+import { MicroserviceProps } from "../interfaces/MicroserviceProps";
+import { CreateMicroServiceBundle } from "../resources/gateway/createMicroServiceBundle";
+import { CreateDynamoDb } from "../resources/dynamodb/CreateDynamo";
+import { Api } from "../resources/gateway/createApi";
+import { getSecretManager } from "../resources/securityManager";
+import { createCommonLayer } from "../resources/helpers/createCommonLayer";
+import { AppConfig } from "../config/AppConfig";
+import { Tags } from "aws-cdk-lib";
+import { TsgLambdaProps } from "../config/types/TsgLambdaProps";
+import { TsgLambdaProp } from "../config/types";
+
+export class MicroService extends Construct {
+
+    protected readonly requireDynamoTables: boolean;
+    protected bundleByVersion: Record<string, CreateMicroServiceBundle> = {};
+    protected appConfig: AppConfig;
+
+    constructor(scope: Construct, id: string, props: MicroserviceProps) {
+        super(scope, id);
+
+        this.appConfig = new AppConfig(props);
+
+        this.requireDynamoTables = (props.RESOURCES.DYNAMO?.TABLES &&
+            props.RESOURCES.DYNAMO.TABLES.length > 0) ? true : false;
+
+        this.onInit(scope, this.appConfig);
+
+        this.createTag(scope)
+    }
+
+    private onInit(scope: Construct, props: AppConfig) {
+
+        let tables: Table[] | undefined = undefined;
+
+        if (!process.env.SECRET_MANAGER_ARN) {
+            throw new Error(`You must provide the ARN for the your Configuration Secret 
+                Manager`);            
+        }
+
+        const secretMgr = getSecretManager(scope, props, process.env.SECRET_MANAGER_ARN);
+
+        const commonLayer = createCommonLayer(scope, props);
+
+        const gateway = new Api(scope, this.appConfig).APIs;
+
+        const layers = [commonLayer];
+
+        // Creates DynamoDb Tables if required
+        if (this.requireDynamoTables) {
+            const dynamo = new CreateDynamoDb(scope, this.appConfig);
+
+            tables = dynamo.CreatedTables;
+        }
+
+        props.RESOURCES.LAMBDA.forEach((bundleProps: TsgLambdaProp) => {
+            
+            new CreateMicroServiceBundle(scope, 
+                gateway[0], props, this.appConfig, tables, secretMgr, layers);
+        });
+    }
+
+    protected createTag(scope: Construct) {
+        Tags.of(scope).add('App', this.appConfig.AppName);
+        Tags.of(scope).add('ResoucePrefix', this.appConfig.AppPrefix);
+    }
+}

package/src/constructs/index.ts

@@ -0,0 +1 @@
+export { MicroService } from "./MicroService";

package/src/index.ts

@@ -0,0 +1,4 @@
+export { MicroService } from "./constructs/MicroService";
+export { MicroserviceProps } from "./interfaces/MicroserviceProps";
+export { IAppConfig } from "./config/customConfigs/IAppConfig";
+export { MicroServiceAppConfig } from "./config/MicroserviceAppConfig";

package/src/interfaces/CreateLambdaFunctionInput.ts

@@ -0,0 +1,11 @@
+import { IRole } from "aws-cdk-lib/aws-iam";
+import { LayerVersion } from "aws-cdk-lib/aws-lambda";
+import { TsgLambdaProp } from "../config/types";
+import { TsgLambdaProps } from "../config/types/TsgLambdaProps";
+
+export interface CreateLambdaFunctionInput {
+    prop: TsgLambdaProp;
+    role?: IRole;
+    layers?: LayerVersion[],
+    props?: TsgLambdaProps
+}

package/src/interfaces/MicroserviceProps.ts

@@ -0,0 +1,11 @@
+import { ApiAppConfig } from "../config/customConfigs/ApiAppConfig";
+import { GlobalAppConfig } from "../config/customConfigs/GlobalAppConfig";
+import { ResourceAppConfig } from "../config/customConfigs/ResourceAppConfig";
+import { TsgDnsAppConfig } from "../config/types/TsgDnsConfig";
+
+export interface MicroserviceProps {
+    API: ApiAppConfig;
+    GLOBALS: GlobalAppConfig;
+    RESOURCES: ResourceAppConfig;
+    DNS: TsgDnsAppConfig;
+}

package/src/resources/base/baseResource.ts

@@ -0,0 +1,15 @@
+import { Tags } from "aws-cdk-lib";
+import { Construct } from "constructs";
+import { AppConfig } from "../../config/AppConfig";
+
+export abstract class BaseResource<T> {
+
+    protected createdResources: T[];
+
+    constructor(protected scope: Construct, protected config: AppConfig) { }
+
+    protected abstract createResource(scope: Construct): T[] | null;
+    
+    protected abstract createOutput<T>(scope: Construct, createdAssets: T[]): void;
+    
+}

package/src/resources/certificate/createCertificate.ts

@@ -0,0 +1,40 @@
+import { RemovalPolicy } from "aws-cdk-lib";
+import { Certificate, CertificateValidation, DnsValidatedCertificate, ICertificate } from "aws-cdk-lib/aws-certificatemanager";
+import { IHostedZone } from "aws-cdk-lib/aws-route53";
+import { Construct } from "constructs";
+import { MicroserviceProps } from "../../interfaces/MicroserviceProps";
+
+
+export class CreateCertificate {
+
+    public certificate: ICertificate;
+
+    constructor(scope: Construct, props: MicroserviceProps, hostedZone: IHostedZone) {
+
+        this.certificate = this.generateCertificate(scope, props, hostedZone);
+
+        this.certificate.applyRemovalPolicy(RemovalPolicy.DESTROY);
+        
+    }
+
+    generateCertificate(scope: Construct, props: MicroserviceProps, hostedZone: IHostedZone) {
+
+        // const cert = new DnsValidatedCertificate(scope, `${props.DNS.ZoneNameWithoutPeriod}-spa-app-certificate`, {
+        //     domainName: `${props.API.DomainPrefix}.${props.DNS.ZoneName}`,
+        //     hostedZone,
+        //     region: props.GLOBALS.region || "us-east-1"
+        //   }); 
+
+          const appType = "spa-app";
+
+          const cert = new Certificate(scope, `${props.DNS.ZoneNameWithoutPeriod}-${appType}-certificate`, {
+            domainName: `${props.API.DomainPrefix}.${props.DNS.ZoneName}`,
+            subjectAlternativeNames: [`${props.API.DomainPrefix}.${props.DNS.ZoneName}`],
+            validation: CertificateValidation.fromDnsMultiZone({                
+                    [`${props.API.DomainPrefix}.${props.DNS.ZoneName}`] : hostedZone ,                
+            }),
+          });
+
+          return cert;
+    }
+}

package/src/resources/cognito/createCognito.ts

@@ -0,0 +1,47 @@
+import { IUserPool, UserPool, UserPoolClient, UserPoolClientProps, UserPoolIdentityProviderAmazon, UserPoolIdentityProviderAmazonProps, UserPoolIdentityProviderSaml, UserPoolIdentityProviderSamlMetadataType } from "aws-cdk-lib/aws-cognito";
+import { Construct } from "constructs";
+import { AppConfig } from "../../config/AppConfig";
+import { createUserPoolProps } from "./createCognitoProps";
+import { Duration } from "aws-cdk-lib";
+import { ClientAppType } from "../../config/Environments";
+
+export const createCognito = (scope: Construct, appConfig: AppConfig) => {
+
+
+    const userPool = createUserPool(scope, appConfig);
+    const clientPool = createUserPoolClient(scope, userPool, "mobile", appConfig);    
+    
+    return {
+        userPool,
+        clientPool
+    };
+};
+
+const createUserPool = (scope: Construct, appConfig: AppConfig, userPoolName?: string) => {
+
+    return new UserPool(scope, `${appConfig.AppName}-user-pool`,
+        createUserPoolProps(`${appConfig.AppName}-user-pool`));
+
+};
+
+const createUserPoolClient = (scope: Construct, userPool: IUserPool, appType: ClientAppType,
+    appConfig: AppConfig) => {
+
+    const client = new UserPoolClient(scope, `${appConfig.AppName}-user-pool-client`,
+        createUserPoolClientProps(userPool, appConfig, appType));
+
+    return client;
+};
+
+const createUserPoolClientProps = (userpool: IUserPool, config: AppConfig, appType: ClientAppType): UserPoolClientProps => {
+    const props: UserPoolClientProps = {
+        userPool: userpool,
+        accessTokenValidity: Duration.hours(3),
+        refreshTokenValidity: Duration.days(3),
+        userPoolClientName: `${config.AppName}-${appType}`,
+        authFlows: {
+            userPassword: true,
+        }
+    };
+    return props;
+};

package/src/resources/cognito/createCognitoProps.ts

@@ -0,0 +1,46 @@
+import { Duration, RemovalPolicy } from "aws-cdk-lib";
+import { AccountRecovery, DateTimeAttribute, NumberAttribute, StringAttribute, UserPoolProps, 
+    VerificationEmailStyle } from "aws-cdk-lib/aws-cognito";
+
+export const createUserPoolProps = (securityUserPool: string) => {
+   
+    const cognitoProps: UserPoolProps = {
+        userPoolName: securityUserPool.toLowerCase(),
+        selfSignUpEnabled: true,
+        userVerification: {
+            emailSubject: 'Verify your email for Bishop CDK Constructs!',
+            emailBody: 'Thanks for creating an account with Bishop CDK Constructs! Your verification code is {####}',
+            emailStyle: VerificationEmailStyle.CODE,
+            smsMessage: 'Thanks for signing up {username} with Bishop CDK Constructs! Your verification code is {####}',
+        },
+        userInvitation: {
+            emailSubject: 'Invite to join Bishop CDK Constructs!',
+            emailBody: 'Hello {username}, you have been invited to join Bishop CDK Constructs! Your temporary password is {####}',
+            smsMessage: 'Your temporary password for {username} with Bishop CDK Constructs is {####}'
+        },
+        signInAliases: {
+            username: true,
+            email: true,
+            phone: true
+        },
+        customAttributes: {
+            'firstName': new StringAttribute({ minLen: 3, maxLen: 30, mutable: true }),
+            'lastName': new StringAttribute({ minLen: 3, maxLen: 30, mutable: true }),
+            'phoneNumber': new StringAttribute({ minLen: 3, maxLen: 30, mutable: true }),
+            'acccountType': new NumberAttribute({ mutable: true }),
+            'joinedOn': new DateTimeAttribute(),
+        },
+        passwordPolicy: {
+            minLength: 8,
+            requireLowercase: true,
+            requireUppercase: true,
+            requireDigits: true,
+            requireSymbols: true,
+            tempPasswordValidity: Duration.days(1),
+        },
+        accountRecovery: AccountRecovery.PHONE_AND_EMAIL,
+        removalPolicy: RemovalPolicy.DESTROY,
+    }
+    return cognitoProps;
+};
+

package/src/resources/dynamodb/CreateDynamo.ts

@@ -0,0 +1,111 @@
+import { CfnOutput, RemovalPolicy } from "aws-cdk-lib";
+import { GlobalSecondaryIndexProps,Table, TableProps } from "aws-cdk-lib/aws-dynamodb";
+import { Construct } from "constructs";
+import { AppConfig } from "../../config/AppConfig";
+import { BaseResource } from "../base/baseResource";
+
+
+export class CreateDynamoDb extends BaseResource<Table> {
+
+    static ReadWriteActions: string[] = [
+        "dynamodb:BatchGetItem",
+        "dynamodb:BatchWriteItem",
+        "dynamodb:ConditionCheckItem",
+        "dynamodb:DeleteItem",
+        "dynamodb:DescribeTable",
+        "dynamodb:GetItem",
+        "dynamodb:GetRecords",
+        "dynamodb:GetShardIterator",
+        "dynamodb:PutItem",
+        "dynamodb:Query",
+        "dynamodb:Scan",
+        "dynamodb:UpdateItem",
+    ];
+
+    get CreatedTables() {
+        return this.createdResources;
+    }
+    
+    constructor(protected scope: Construct, protected config: AppConfig) {
+        super(scope, config);
+
+        this.createdResources = this.createResource(scope);
+
+        if (this.createdResources) {
+            this.createOutput(scope, this.createdResources);
+        }
+    }
+
+    protected createResource(scope: Construct): Table[] {
+        
+            const props = this.createProps();
+
+            const tables = props?.map((prop: any, idx: number) => {
+                const dbTable = new Table(scope, `${prop.tableName}`, {
+                    ...prop,
+                    removalPolicy: RemovalPolicy.DESTROY
+                });
+
+                this.config.RESOURCES.DYNAMO?.TABLES?.[idx].indexes.map((gsi) => {
+
+                    const gsiProps: GlobalSecondaryIndexProps = {
+                        indexName: this.generateDbName(gsi.indexName),
+                        partitionKey: gsi.partitionKey,
+                        sortKey: gsi.sortKey,
+                        projectionType: gsi.projectionType
+
+                    };
+
+                    dbTable.addGlobalSecondaryIndex(gsiProps);
+                });
+                return dbTable;
+            });
+
+            return tables ?? [];
+       
+
+       
+    }
+
+
+    protected createOutput<T>(scope: Construct, createdAssets: T[]): void {
+        this.createdResources!.forEach((x, idx) => {
+            new CfnOutput(scope, `dynamoTable${idx}`, {
+                value: x.tableName
+            });
+        });
+    }
+
+    private createProps() {
+        const props = this.config.RESOURCES?.DYNAMO?.TABLES?.map((x) => {
+
+            const prop: any = {};
+
+            prop.tableName = this.generateDbName(x.tableName);
+                        
+            prop.partitionKey = {
+                name: x.primaryKey.name,
+                type: x.primaryKey.type
+            };
+
+            prop.billingMode = x.billingMode;
+
+            if (x.sortKey) {
+                prop.sortKey = {
+                    name: x.sortKey.name,
+                    type: x.sortKey.type,
+                }
+            }
+            return prop as TableProps;
+        });
+
+        return props;
+    }
+
+    private generateDbName(tableName: string) {
+        // TODO:  Remove this later  table names should have appPrefix
+        return `${tableName}`;
+        
+        // return `${this.config.AppPrefix}-${tableName}`;
+    }
+}

package/src/resources/gateway/createApi.ts

@@ -0,0 +1,138 @@
+import { CfnOutput, Tag } from "aws-cdk-lib";
+import { BasePathMapping, Cors, CorsOptions, DomainName, EndpointType, IDomainName, IRestApi, MethodOptions, RestApi, RestApiProps, SecurityPolicy } from "aws-cdk-lib/aws-apigateway";
+import { ARecord, HostedZone, IHostedZone, RecordTarget } from "aws-cdk-lib/aws-route53";
+import { ApiGateway, ApiGatewayDomain } from "aws-cdk-lib/aws-route53-targets";
+import { Construct } from "constructs";
+import { AppConfig } from "../../config/AppConfig";
+import { MicroserviceProps } from "../../interfaces/MicroserviceProps";
+
+import { BaseResource } from "../base/baseResource";
+import { CreateCertificate } from "../certificate/createCertificate";
+
+export class Api extends BaseResource<IRestApi> {
+    
+    private corsOptions: CorsOptions;
+    
+
+    get APIs() {
+        return this.createdResources;
+    }
+
+    constructor(scope: Construct, config: AppConfig) {
+        super(scope, config);
+
+        this.corsOptions = this.createDefaultCorsOptions();  
+        
+        this.createdResources = this.createResource(scope);
+    }
+
+    private createApi(scope: Construct) {
+        const zone = this.getZone(this.scope, this.config);
+
+        const api = new RestApi(this.scope, `${this.config.AppPrefix}-rest-api`, this.createApiProps(zone));
+
+        this.createARecord(scope, zone, api);
+
+        return api;
+    }
+
+    private createApiProps(zone: IHostedZone): RestApiProps {
+        
+        const cert = this.createCertificate(this.scope, zone, this.config);
+
+        const props: RestApiProps = {
+            restApiName: `gs-api-${this.config.AppPrefix}-${this.config.API.Name}`, 
+            description: this.config.API.Description,
+            domainName: {
+                domainName: `${this.config.API.DomainPrefix}.${this.config.DNS.ZoneName}`,
+                certificate: cert.certificate,
+                endpointType: EndpointType.EDGE,
+                securityPolicy: SecurityPolicy.TLS_1_2
+            },
+            // TODO:  ADD CUSTOM DOMAIN HERE
+            // defaultDomainMapping: {
+            //     domainName: domain,            
+            //   },
+            // domainName: '',
+            defaultCorsPreflightOptions: this.corsOptions
+        };
+
+        return props;
+    }
+
+    private createDefaultCorsOptions() {
+
+        const corsOptions: CorsOptions = {
+            allowHeaders: [
+                '*',
+            ],
+            allowMethods: Cors.ALL_METHODS,
+            allowCredentials: true,
+            allowOrigins: Cors.ALL_ORIGINS,
+        };
+
+        return corsOptions;
+    }
+    
+    private createCustomDomain(scope: Construct, config: MicroserviceProps) {
+        const domainName = DomainName.fromDomainNameAttributes(scope, `${config.API.Name}-custom-domain`, {
+            domainName: config.DNS.ZoneName,
+            domainNameAliasHostedZoneId: config.DNS.ZoneId!,
+            domainNameAliasTarget: config.API.DomainPrefix!,
+          });
+
+          return domainName
+    }
+   
+    private attachDomainToApi(scope: Construct, api: IRestApi, domain: IDomainName, config: MicroserviceProps) {
+        return new BasePathMapping(scope, `${config.API.Name}-basePathMapping`, {
+            domainName: domain,
+            restApi: api,
+          });
+    }
+
+    private getZone(scope: Construct, config: MicroserviceProps) {
+        return HostedZone.fromHostedZoneAttributes(scope, `${config.DNS.ZoneName}-zone`, {
+            zoneName: config.DNS.ZoneName,
+            hostedZoneId: config.DNS.ZoneId!
+        });
+    }
+
+    private createCertificate(scope: Construct, zone: IHostedZone, config: MicroserviceProps) {
+        const cert = new CreateCertificate(scope, config, zone);
+        return cert;
+    }
+
+    private createARecord(scope: Construct, zone: IHostedZone, api: RestApi) {
+        return new ARecord(scope, "ApiRecord", {
+            zone,
+            target: RecordTarget.fromAlias(new ApiGateway(api)),
+            recordName: this.config.API.DomainPrefix
+        });
+            
+    }    
+
+    protected createResource(scope: Construct) {        
+
+        const api = this.createApi(scope);
+        // TODO:  ONLY IF CUSTOM MAPPING IS REQUIRED
+        // const domain = this.createCustomDomain(scope, this.config);
+
+        // const mapping = this.attachDomainToApi(scope, api, domain, this.config);
+
+        
+
+        return [api];
+    }
+
+    protected createOutput<T>(scope: Construct, createdAssets: T[]): void {
+        createdAssets.forEach((api, idx) => {
+
+            new CfnOutput(scope, `api${idx}`, {                
+                // @ts-ignore
+                value: api.url
+            });
+        });
+    }
+    
+}