@sylvesterllc/aws-constructs 1.1.11 → 1.1.13

package/src/resources/gateway/createApiKey.ts

@@ -1,89 +1,89 @@
-import { Construct } from "constructs";
-import { BaseResource } from "../base/baseResource";
-import { ApiKeyProps, IApiKey, ApiKey as AWS_API_KEY, IRestApi, RestApi } from "aws-cdk-lib/aws-apigateway";
-import { AppConfig } from "../../config/AppConfig";
-import { CfnOutput, RemovalPolicy } from "aws-cdk-lib";
-import { UsagePlanProps } from "aws-cdk-lib/aws-apigateway";
-
-export class TsgApiKey extends BaseResource<AWS_API_KEY> {
-
-
-    private api: RestApi;    
-    private apiKey: IApiKey;
-
-    constructor(scope: Construct, config: AppConfig, api: RestApi) {
-        super(scope, config);
-
-        this.api = api;       
-
-        this.createdResources = this.createResource(scope);
-
-        this.applyRemovalPolicy();
-
-        this.createOutput(scope, this.createdResources);
-    }
-
-    get APIKey() {
-        return this.apiKey;
-    }
-
-    public createResource(scope: Construct): AWS_API_KEY[] {
-
-        const keyProps: ApiKeyProps = {
-            apiKeyName: `${this.config.AppPrefix}-x-api-key`,
-            resources: [this.api],
-            value: `ddGTsLQrae2U6zTEjw4M07qO4pHGt60u73zImLHE`,
-            enabled: true,
-            description: `API App Key for ${this.config.AppName}`,
-
-        };
-
-        const apiKey = new AWS_API_KEY(scope, `${this.config.AppPrefix}-api-key`, keyProps);
-
-        this.createUsagePlan(scope, this.config, this.api, apiKey);
-
-        return [apiKey];
-    }
-
-    protected createOutput<T>(scope: Construct, createdAssets: T[]): void {
-        this.createdResources.forEach((key, idx) => {
-
-            new CfnOutput(scope, `api-key-${idx}`, {
-                value: `${key.keyId}\t${key.keyArn}`
-            });
-        });
-    }
-
-    private applyRemovalPolicy() {
-
-        const apiKey = this.createdResources[0];
-
-        if (apiKey) {
-            apiKey.applyRemovalPolicy(RemovalPolicy.DESTROY);
-        }
-    }
-
-    private createUsagePlan(scope: Construct, config: AppConfig, api: RestApi, apiKey: AWS_API_KEY) {
-
-        const planProps: UsagePlanProps = {
-            name: `${config.AppName}-easy-plan`,
-            throttle: {
-                rateLimit: 1000,
-                burstLimit: 10,
-            },
-            apiStages: [
-                {
-                    api: api,
-                    stage: api.deploymentStage,
-                },
-            ],
-        };
-
-        const plan = api.addUsagePlan(
-            `${config.AppPrefix}-${config.AppName}-usage-plan`,
-            planProps
-        );
-
-        plan.addApiKey(apiKey);
-    }
+import { Construct } from "constructs";
+import { BaseResource } from "../base/baseResource";
+import { ApiKeyProps, IApiKey, ApiKey as AWS_API_KEY, IRestApi, RestApi } from "aws-cdk-lib/aws-apigateway";
+import { AppConfig } from "../../config/AppConfig";
+import { CfnOutput, RemovalPolicy } from "aws-cdk-lib";
+import { UsagePlanProps } from "aws-cdk-lib/aws-apigateway";
+
+export class TsgApiKey extends BaseResource<AWS_API_KEY> {
+
+
+    private api: RestApi;    
+    private apiKey: IApiKey;
+
+    constructor(scope: Construct, config: AppConfig, api: RestApi) {
+        super(scope, config);
+
+        this.api = api;       
+
+        this.createdResources = this.createResource(scope);
+
+        this.applyRemovalPolicy();
+
+        this.createOutput(scope, this.createdResources);
+    }
+
+    get APIKey() {
+        return this.apiKey;
+    }
+
+    public createResource(scope: Construct): AWS_API_KEY[] {
+
+        const keyProps: ApiKeyProps = {
+            apiKeyName: `${this.config.AppPrefix}-x-api-key`,
+            resources: [this.api],
+            value: `ddGTsLQrae2U6zTEjw4M07qO4pHGt60u73zImLHE`,
+            enabled: true,
+            description: `API App Key for ${this.config.AppName}`,
+
+        };
+
+        const apiKey = new AWS_API_KEY(scope, `${this.config.AppPrefix}-api-key`, keyProps);
+
+        this.createUsagePlan(scope, this.config, this.api, apiKey);
+
+        return [apiKey];
+    }
+
+    protected createOutput<T>(scope: Construct, createdAssets: T[]): void {
+        this.createdResources.forEach((key, idx) => {
+
+            new CfnOutput(scope, `api-key-${idx}`, {
+                value: `${key.keyId}\t${key.keyArn}`
+            });
+        });
+    }
+
+    private applyRemovalPolicy() {
+
+        const apiKey = this.createdResources[0];
+
+        if (apiKey) {
+            apiKey.applyRemovalPolicy(RemovalPolicy.DESTROY);
+        }
+    }
+
+    private createUsagePlan(scope: Construct, config: AppConfig, api: RestApi, apiKey: AWS_API_KEY) {
+
+        const planProps: UsagePlanProps = {
+            name: `${config.AppName}-easy-plan`,
+            throttle: {
+                rateLimit: 1000,
+                burstLimit: 10,
+            },
+            apiStages: [
+                {
+                    api: api,
+                    stage: api.deploymentStage,
+                },
+            ],
+        };
+
+        const plan = api.addUsagePlan(
+            `${config.AppPrefix}-${config.AppName}-usage-plan`,
+            planProps
+        );
+
+        plan.addApiKey(apiKey);
+    }
 }

package/src/resources/helpers/createCommonLayer.ts

@@ -1,18 +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: appProps.RESOURCES.LAMBDA_LAYERS![0].description,
-        codePath: appProps.RESOURCES.LAMBDA_LAYERS![0].codePath,
-        name: appProps.RESOURCES.LAMBDA_LAYERS![0].name,
-    };  
-    
-    const layer = createLambdaLayer(scope, appProps, prop)
-    
-    return [layer];
-};
-
+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: appProps.RESOURCES.LAMBDA_LAYERS![0].description,
+        codePath: appProps.RESOURCES.LAMBDA_LAYERS![0].codePath,
+        name: appProps.RESOURCES.LAMBDA_LAYERS![0].name,
+    };  
+    
+    const layer = createLambdaLayer(scope, appProps, prop)
+    
+    return [layer];
+};
+

package/src/resources/helpers/createRoutes.ts

@@ -1,75 +1,75 @@
-import { AuthorizationType, IRestApi, LambdaIntegration, RequestAuthorizer, Resource, TokenAuthorizer } from "aws-cdk-lib/aws-apigateway";
-import { NodejsFunction } from "aws-cdk-lib/aws-lambda-nodejs";
-import { TsgLambdaProp } from "../../config/types";
-import { Logger } from "../../helpers/logger";
-import { logger } from "../layers/common/src/nodejs";
-
-
-export class Routes {
-
-    public static Resources: Resource[] = [];
-    private static routeMap = new Map();
-
-    public static createResource(
-        prop: TsgLambdaProp,
-        api: IRestApi,
-        lambdaNode: NodejsFunction,
-        authorizer?: TokenAuthorizer | RequestAuthorizer,
-    ): void {
-
-        const routeMap: Map<string, Resource> = new Map();
-
-        let activeRoutePath = "";
-        let activeResource: Resource | undefined = undefined;
-
-        //  Only attach lambda to an Api Gateway if a route exist
-        if (prop.apiGateway?.route) {
-
-            if (!prop.apiGateway.useRouteOverride) {
-                //  First we create the root resource if it doesn't exist.
-                //  Note:  this now uses the bundle version as the first segment in the path.
-                activeRoutePath = `v${(prop.apiGateway?.version) ? prop.apiGateway.version : 1}`;
-                activeResource = 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]) || api.root.addResource(pathSegments[i]);
-                Routes.routeMap.set(activeRoutePath, secondaryResource);
-                activeResource = secondaryResource;
-            }
-
-            //    console.log(`Route: ${prop.apiGateway.method}\t Lambda Name: ${lambdaNode.node.id}\t Path: ${activeRoutePath}`);
-            //  Finally, we attach our function to the last resource
-            activeResource?.addMethod(prop.apiGateway.method || 'GET',
-                new LambdaIntegration(lambdaNode, { proxy: true, }),
-                {
-                    requestParameters: Routes.createQueryStringObject(prop.apiGateway.queryStrings),
-                    apiKeyRequired: (prop.apiGateway.requireApiKey) ? true : false,
-                    authorizer: prop.apiGateway.secure ? authorizer : undefined,
-                    authorizationType: prop.apiGateway.secure ? AuthorizationType.CUSTOM : undefined,
-                });
-        }
-    }
-
-    public static createQueryStringObject(queryStrings: string[] | undefined): { [key: string]: boolean } {
-
-        if (!queryStrings || queryStrings.length === 0) {
-            return {};
-        }
-
-        const obj: { [key: string]: boolean } = {};
-
-        queryStrings.forEach((qs: string) => {
-            obj[`method.request.querystring.${qs}`] = true;
-        });
-
-        return obj;
-    }
-
+import { AuthorizationType, IRestApi, LambdaIntegration, RequestAuthorizer, Resource, TokenAuthorizer } from "aws-cdk-lib/aws-apigateway";
+import { NodejsFunction } from "aws-cdk-lib/aws-lambda-nodejs";
+import { TsgLambdaProp } from "../../config/types";
+import { Logger } from "../../helpers/logger";
+import { logger } from "../layers/common/src/nodejs";
+
+
+export class Routes {
+
+    public static Resources: Resource[] = [];
+    private static routeMap = new Map();
+
+    public static createResource(
+        prop: TsgLambdaProp,
+        api: IRestApi,
+        lambdaNode: NodejsFunction,
+        authorizer?: TokenAuthorizer | RequestAuthorizer,
+    ): void {
+
+        const routeMap: Map<string, Resource> = new Map();
+
+        let activeRoutePath = "";
+        let activeResource: Resource | undefined = undefined;
+
+        //  Only attach lambda to an Api Gateway if a route exist
+        if (prop.apiGateway?.route) {
+
+            if (!prop.apiGateway.useRouteOverride) {
+                //  First we create the root resource if it doesn't exist.
+                //  Note:  this now uses the bundle version as the first segment in the path.
+                activeRoutePath = `v${(prop.apiGateway?.version) ? prop.apiGateway.version : 1}`;
+                activeResource = 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]) || api.root.addResource(pathSegments[i]);
+                Routes.routeMap.set(activeRoutePath, secondaryResource);
+                activeResource = secondaryResource;
+            }
+
+            //    console.log(`Route: ${prop.apiGateway.method}\t Lambda Name: ${lambdaNode.node.id}\t Path: ${activeRoutePath}`);
+            //  Finally, we attach our function to the last resource
+            activeResource?.addMethod(prop.apiGateway.method || 'GET',
+                new LambdaIntegration(lambdaNode, { proxy: true, }),
+                {
+                    requestParameters: Routes.createQueryStringObject(prop.apiGateway.queryStrings),
+                    apiKeyRequired: (prop.apiGateway.requireApiKey) ? true : false,
+                    authorizer: prop.apiGateway.secure ? authorizer : undefined,
+                    authorizationType: prop.apiGateway.secure ? AuthorizationType.CUSTOM : undefined,
+                });
+        }
+    }
+
+    public static createQueryStringObject(queryStrings: string[] | undefined): { [key: string]: boolean } {
+
+        if (!queryStrings || queryStrings.length === 0) {
+            return {};
+        }
+
+        const obj: { [key: string]: boolean } = {};
+
+        queryStrings.forEach((qs: string) => {
+            obj[`method.request.querystring.${qs}`] = true;
+        });
+
+        return obj;
+    }
+
 }

package/src/resources/index.ts

@@ -1 +1 @@
-export { CreateCertificate } from "./certificate/createCertificate";
+export { CreateCertificate } from "./certificate/createCertificate";

package/src/resources/lambda/create-basic-lambda.ts

@@ -0,0 +1,104 @@
+import { Duration } from "aws-cdk-lib";
+import { ServicePrincipal } from "aws-cdk-lib/aws-iam";
+import { LayerVersion, Runtime } from "aws-cdk-lib/aws-lambda";
+import { NodejsFunction, NodejsFunctionProps, SourceMapMode } from "aws-cdk-lib/aws-lambda-nodejs";
+import { RetentionDays } from "aws-cdk-lib/aws-logs";
+import path = require("path");
+import { TimerJobProps } from "../../interfaces/timer-job";
+import { Construct } from "constructs";
+import { SERVICE_PRINCIPAL } from "../../constants/aws-service-principal-constants";
+import { CronOptions, Rule, Schedule } from "aws-cdk-lib/aws-events";
+import { LambdaFunction } from "aws-cdk-lib/aws-events-targets";
+import { Table } from "aws-cdk-lib/aws-dynamodb";
+
+
+
+export const createBasicLambdaTimerJob = (scope: Construct, props: TimerJobProps) => {
+
+    const lambdaProps = createBasicLambdaProps(props);
+
+    let lambdaFunction = new NodejsFunction(scope, `${props.appPrefix}${props.functionName}`, lambdaProps);
+
+    addInvokePermissionToLambdaForEvents(lambdaFunction);
+
+    const eventRule = createEventRuleForLambda(scope, lambdaFunction, props.cronOptions);
+
+    eventRule.addTarget(new LambdaFunction(lambdaFunction));
+
+    grantAccessToDynamoTables(scope, lambdaFunction, props.dynamoTableNames);
+   
+    addLambdaLayers(scope, lambdaFunction, props.lambdaLayerArn);
+};
+
+const createBasicLambdaProps = (props: TimerJobProps) => {
+
+         const lambdaProp: NodejsFunctionProps = {
+            entry: (props.codePath) ? path.join(props.codePath) : path.join(`./resources/lambdas/timer-jobs/${props.functionName}/main.mts`),
+            functionName: `${(props.appPrefix) ? `${props.appPrefix}-` : ''}${props.functionName}`,
+            handler: 'main.ts',
+            logRetention: RetentionDays.TWO_WEEKS,
+            runtime: Runtime.NODEJS_LATEST,
+            timeout: Duration.minutes((props.timeoutInMinutes) ? props.timeoutInMinutes : 1),
+            memorySize: props.memory,
+            environment: {                
+                ...props.envs
+            },
+            bundling: {
+                minify: true,
+                target: `esnext`,
+                sourceMap: true,
+                sourceMapMode: SourceMapMode.EXTERNAL,
+                environment: {
+                    ...props.envs
+                }
+            },
+           role: props.role,
+           layers: undefined
+        }
+
+        return lambdaProp;
+};
+
+const addInvokePermissionToLambdaForEvents = (lambda: NodejsFunction) => {
+
+     lambda.addPermission(`InvokePermission-${lambda.functionName}`, {
+            principal: new ServicePrincipal(SERVICE_PRINCIPAL.EVENTS),
+        });
+};
+
+const createEventRuleForLambda = (scope: Construct, lambda: NodejsFunction, options: CronOptions) => {
+     
+    const eventRule = new Rule(scope, `scheduleRule-${lambda?.node.id || '010'}`, {
+            schedule: Schedule.cron(options),
+     });
+
+    return eventRule;
+};
+
+const grantAccessToDynamoTables = (scope: Construct, lambda: NodejsFunction, tableNames?: string[]) => {
+
+    if (tableNames && tableNames.length > 0) {            
+
+            tableNames.forEach(tableName => {
+
+                const table = Table.fromTableName(scope, `${tableName}-table`, tableName);
+
+                table.grantReadWriteData(lambda);
+            });
+        
+            
+
+        }
+};
+
+const addLambdaLayers = (scope: Construct, lambda: NodejsFunction, layerArns?: string[]) => {
+
+    if (layerArns &&  layerArns.length > 0) {
+        layerArns.forEach((arn: string, idx: number) => {
+            const layer = LayerVersion.fromLayerVersionArn(scope, `common-layer-${idx}`, arn);
+
+            lambda.addLayers(layer);
+            
+        });
+    }
+};