@sylvesterllc/aws-constructs 1.1.11 → 1.1.13

package/src/resources/lambda/lambdaHelper.ts

@@ -1,134 +1,134 @@
-import { IRole } from "aws-cdk-lib/aws-iam";
-import { LayerVersion } from "aws-cdk-lib/aws-lambda";
-import { Construct } from "constructs";
-import { TsgLambdaProp } from "../../config/types";
-import { NodejsFunction, NodejsFunctionProps, SourceMapMode } from "aws-cdk-lib/aws-lambda-nodejs";
-import { TsgLambdaProps } from "../../config/types/TsgLambdaProps";
-import { CreateLambdaFunctionInput } from "../../interfaces/CreateLambdaFunctionInput";
-import * as path from "node:path";
-import { AppConfig } from "../../config/AppConfig";
-import { RetentionDays } from "aws-cdk-lib/aws-logs";
-import { Duration } from "aws-cdk-lib";
-import { LogDuration } from "../../config/types/LogDuration";
-
-
-export class LambdaHelper {
-
-    public static createLambdaFunctions(scope: Construct,
-        config: AppConfig,
-        lambdaConfigs: TsgLambdaProp | TsgLambdaProp[],
-        role?: IRole,
-        layers?: LayerVersion[]) {
-
-        const isArrayOfLambdaProps = Array.isArray(lambdaConfigs);
-
-        const appConfig = config;
-
-        if (isArrayOfLambdaProps) {
-            const createdLambdas = lambdaConfigs.map((config: TsgLambdaProp) => {
-
-                return LambdaHelper.createLambda(config, role, layers, appConfig, scope);
-            });
-            return createdLambdas || [];
-        } else {
-            return LambdaHelper.createLambda(lambdaConfigs as TsgLambdaProp, role, layers, config, scope);
-        }
-    }
-
-    private static createLambda(config: TsgLambdaProp,
-        role: IRole | undefined,
-        layers: LayerVersion[] | undefined,
-        appConfig: AppConfig,
-        scope: Construct) {
-
-        let lambdaProps = this.createLambdaProps(config, role, layers, {
-            appConfig: appConfig,
-            role,
-            layers,
-            scope
-        });
-
-        const lambdaId = this.getIdForLambda(config, appConfig);
-        let fctn = new NodejsFunction(scope, lambdaId, lambdaProps);
-
-        if (lambdaId !== fctn.node.id) {
-            console.error(`can not find Lambda for : ${fctn.node.id}`);
-        }
-
-        return fctn;
-    }
-
-    private static createLambdaProps(prop: TsgLambdaProp,
-        role?: IRole,
-        layers?: LayerVersion[],
-        props?: TsgLambdaProps) {
-
-        return this.createLambdaFunctionProps({
-            prop,
-            role,
-            layers,
-            props
-        });
-    }
-
-    private static createLambdaFunctionProps(props: CreateLambdaFunctionInput) {
-        const { prop, role, layers } = props;
-
-        const config = props.props?.appConfig;
-
-        const lambdaProp: NodejsFunctionProps = {
-            entry: path.join(prop.codePath),
-            functionName: `${config?.AppPrefix}-${prop.name}`,
-            handler: prop.handler,
-            logRetention: (!prop.logDuration) ? RetentionDays.FIVE_DAYS :
-                LambdaHelper.getDayToSaveLogs(prop.logDuration),
-            runtime: prop.runtime || config?.GLOBALS.stackRuntime,
-            timeout: prop.duration || Duration.minutes(2),
-            memorySize: prop.memory || 512,
-            environment: {
-                "VERBOSE_LOGGING": "true",
-                ...prop.environment
-            },
-            bundling: {
-                minify: true,
-                target: "ESNext",
-                sourceMap: true,
-                sourceMapMode: SourceMapMode.EXTERNAL,
-                environment: prop.environment || prop.environment,
-            },
-            role,
-            layers
-
-        }
-        return lambdaProp;
-    };
-
-    public static getDayToSaveLogs(saveLogDuration: LogDuration): RetentionDays {
-
-        switch (saveLogDuration) {
-            case LogDuration.ONE_DAY:
-                return RetentionDays.ONE_DAY;
-
-            case LogDuration.ONE_WEEK:
-                return RetentionDays.ONE_WEEK;
-
-            case LogDuration.ONE_MONTH:
-                return RetentionDays.ONE_MONTH;
-
-            case LogDuration.ONE_YEAR:
-                return RetentionDays.ONE_YEAR;
-
-            case LogDuration.FIVE_YEARS:
-                return RetentionDays.FIVE_YEARS;
-
-            case LogDuration.FOREVER:
-                return RetentionDays.INFINITE;
-            default:
-                return RetentionDays.FIVE_DAYS;
-        }
-    }
-
-    public static getIdForLambda(lambdaProp: TsgLambdaProp, appConfig: AppConfig) {
-        return `${appConfig.AppPrefix}-${lambdaProp.name}`.toLowerCase();
-    }
+import { IRole } from "aws-cdk-lib/aws-iam";
+import { LayerVersion } from "aws-cdk-lib/aws-lambda";
+import { Construct } from "constructs";
+import { TsgLambdaProp } from "../../config/types";
+import { NodejsFunction, NodejsFunctionProps, SourceMapMode } from "aws-cdk-lib/aws-lambda-nodejs";
+import { TsgLambdaProps } from "../../config/types/TsgLambdaProps";
+import { CreateLambdaFunctionInput } from "../../interfaces/CreateLambdaFunctionInput";
+import * as path from "node:path";
+import { AppConfig } from "../../config/AppConfig";
+import { RetentionDays } from "aws-cdk-lib/aws-logs";
+import { Duration } from "aws-cdk-lib";
+import { LogDuration } from "../../config/types/LogDuration";
+
+
+export class LambdaHelper {
+
+    public static createLambdaFunctions(scope: Construct,
+        config: AppConfig,
+        lambdaConfigs: TsgLambdaProp | TsgLambdaProp[],
+        role?: IRole,
+        layers?: LayerVersion[]) {
+
+        const isArrayOfLambdaProps = Array.isArray(lambdaConfigs);
+
+        const appConfig = config;
+
+        if (isArrayOfLambdaProps) {
+            const createdLambdas = lambdaConfigs.map((config: TsgLambdaProp) => {
+
+                return LambdaHelper.createLambda(config, role, layers, appConfig, scope);
+            });
+            return createdLambdas || [];
+        } else {
+            return LambdaHelper.createLambda(lambdaConfigs as TsgLambdaProp, role, layers, config, scope);
+        }
+    }
+
+    private static createLambda(config: TsgLambdaProp,
+        role: IRole | undefined,
+        layers: LayerVersion[] | undefined,
+        appConfig: AppConfig,
+        scope: Construct) {
+
+        let lambdaProps = this.createLambdaProps(config, role, layers, {
+            appConfig: appConfig,
+            role,
+            layers,
+            scope
+        });
+
+        const lambdaId = this.getIdForLambda(config, appConfig);
+        let fctn = new NodejsFunction(scope, lambdaId, lambdaProps);
+
+        if (lambdaId !== fctn.node.id) {
+            console.error(`can not find Lambda for : ${fctn.node.id}`);
+        }
+
+        return fctn;
+    }
+
+    private static createLambdaProps(prop: TsgLambdaProp,
+        role?: IRole,
+        layers?: LayerVersion[],
+        props?: TsgLambdaProps) {
+
+        return this.createLambdaFunctionProps({
+            prop,
+            role,
+            layers,
+            props
+        });
+    }
+
+    private static createLambdaFunctionProps(props: CreateLambdaFunctionInput) {
+        const { prop, role, layers } = props;
+
+        const config = props.props?.appConfig;
+
+        const lambdaProp: NodejsFunctionProps = {
+            entry: path.join(prop.codePath),
+            functionName: `${config?.AppPrefix}-${prop.name}`,
+            handler: prop.handler,
+            logRetention: (!prop.logDuration) ? RetentionDays.FIVE_DAYS :
+                LambdaHelper.getDayToSaveLogs(prop.logDuration),
+            runtime: prop.runtime || config?.GLOBALS.stackRuntime,
+            timeout: prop.duration || Duration.minutes(2),
+            memorySize: prop.memory || 512,
+            environment: {
+                "VERBOSE_LOGGING": "true",
+                ...prop.environment
+            },
+            bundling: {
+                minify: true,
+                target: "ESNext",
+                sourceMap: true,
+                sourceMapMode: SourceMapMode.EXTERNAL,
+                environment: prop.environment || prop.environment,
+            },
+            role,
+            layers
+
+        }
+        return lambdaProp;
+    };
+
+    public static getDayToSaveLogs(saveLogDuration: LogDuration): RetentionDays {
+
+        switch (saveLogDuration) {
+            case LogDuration.ONE_DAY:
+                return RetentionDays.ONE_DAY;
+
+            case LogDuration.ONE_WEEK:
+                return RetentionDays.ONE_WEEK;
+
+            case LogDuration.ONE_MONTH:
+                return RetentionDays.ONE_MONTH;
+
+            case LogDuration.ONE_YEAR:
+                return RetentionDays.ONE_YEAR;
+
+            case LogDuration.FIVE_YEARS:
+                return RetentionDays.FIVE_YEARS;
+
+            case LogDuration.FOREVER:
+                return RetentionDays.INFINITE;
+            default:
+                return RetentionDays.FIVE_DAYS;
+        }
+    }
+
+    public static getIdForLambda(lambdaProp: TsgLambdaProp, appConfig: AppConfig) {
+        return `${appConfig.AppPrefix}-${lambdaProp.name}`.toLowerCase();
+    }
 }

package/src/resources/lambda-authorizer/TsgJwtTokenAuthorizer.ts

@@ -1,108 +1,108 @@
-import { CfnOutput, Duration } from "aws-cdk-lib";
-import { IdentitySource, TokenAuthorizer, TokenAuthorizerProps } 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 TsgJwtTokenAuthorizer extends BaseResource<TokenAuthorizer> {
-
-    get JwtAuthorizer() {
-        return this.createdResources[0];
-    }
-
-    constructor(scope: Construct, props: AppConfig) {
-
-        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.config.RESOURCES.AUTHORIZER!)];
-    }
-
-    private createLambdaAuthorizer(scope: Construct, lambdaConfig: TsgLambdaProp) {
-        //console.log("ENTER createLambdaAuthorizer");
-
-        const authorizerProps = this.createLambdaFunctionProps(lambdaConfig!);
-
-        const lambdaId = CreateLambda.getIdForLambda(lambdaConfig, this.config);
-        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 props: TokenAuthorizerProps = {
-            handler: lambda,
-            authorizerName: lambdaConfig.name,
-            resultsCacheTtl: Duration.seconds(0), 
-            identitySource: IdentitySource.header('Authorization'),
-            
-        };
-
-        const lambdaAuthorizer = new TokenAuthorizer(scope, `${lambdaConfig.name}-authorizer`, props);
-
-        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);
-        });
-
-    }
-
+import { CfnOutput, Duration } from "aws-cdk-lib";
+import { IdentitySource, TokenAuthorizer, TokenAuthorizerProps } 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 TsgJwtTokenAuthorizer extends BaseResource<TokenAuthorizer> {
+
+    get JwtAuthorizer() {
+        return this.createdResources[0];
+    }
+
+    constructor(scope: Construct, props: AppConfig) {
+
+        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.config.RESOURCES.AUTHORIZER!)];
+    }
+
+    private createLambdaAuthorizer(scope: Construct, lambdaConfig: TsgLambdaProp) {
+        //console.log("ENTER createLambdaAuthorizer");
+
+        const authorizerProps = this.createLambdaFunctionProps(lambdaConfig!);
+
+        const lambdaId = CreateLambda.getIdForLambda(lambdaConfig, this.config);
+        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 props: TokenAuthorizerProps = {
+            handler: lambda,
+            authorizerName: lambdaConfig.name,
+            resultsCacheTtl: Duration.seconds(0), 
+            identitySource: IdentitySource.header('Authorization'),
+            
+        };
+
+        const lambdaAuthorizer = new TokenAuthorizer(scope, `${lambdaConfig.name}-authorizer`, props);
+
+        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/lambda-authorizer/TsgRequestAuthorizer.ts

@@ -1,45 +1,45 @@
-import { RequestAuthorizer } from "aws-cdk-lib/aws-apigateway";
-import { Construct } from "constructs";
-import { AppConfig } from "../../config/AppConfig";
-import { BaseResource } from "../base/baseResource";
-
-import { CfnOutput } from "aws-cdk-lib";
-import { createAuthorizer } from "./createAuthorizerHelpers";
-import { LayerVersion } from "aws-cdk-lib/aws-lambda";
-import { ITableV2 } from "aws-cdk-lib/aws-dynamodb";
-
-
-export class TsgRequestAuthorizer extends BaseResource<RequestAuthorizer> {
-
-    get TsgRequestAuthorizer() {
-        return this.createdResources[0];
-    }
-
-    constructor(scope: Construct, 
-        config: AppConfig, 
-        private layers?: LayerVersion[], 
-        private tables?: ITableV2[]) {
-        super(scope, config);
-
-        this.createdResources = this.createResource(scope)!;        
-    }
-
-    protected createResource(scope: Construct): RequestAuthorizer[] | null {
-        
-        const authorizer = createAuthorizer(scope, this.config, this.layers, this.tables);
-        
-        return [authorizer];
-        
-    }
-
-    protected createOutput<T>(scope: Construct, createdAssets: T[]): void {
-        createdAssets?.forEach((asset) => {
-            if (asset instanceof RequestAuthorizer) {
-                // Output the ARN of the authorizer
-                new CfnOutput(scope, "RequestAuthorizerArn", {
-                    value: `${asset.authorizationType}:${asset.authorizerArn}`
-                });
-            }
-        });
-    }
+import { RequestAuthorizer } from "aws-cdk-lib/aws-apigateway";
+import { Construct } from "constructs";
+import { AppConfig } from "../../config/AppConfig";
+import { BaseResource } from "../base/baseResource";
+
+import { CfnOutput } from "aws-cdk-lib";
+import { createAuthorizer } from "./createAuthorizerHelpers";
+import { LayerVersion } from "aws-cdk-lib/aws-lambda";
+import { ITableV2 } from "aws-cdk-lib/aws-dynamodb";
+
+
+export class TsgRequestAuthorizer extends BaseResource<RequestAuthorizer> {
+
+    get TsgRequestAuthorizer() {
+        return this.createdResources[0];
+    }
+
+    constructor(scope: Construct, 
+        config: AppConfig, 
+        private layers?: LayerVersion[], 
+        private tables?: ITableV2[]) {
+        super(scope, config);
+
+        this.createdResources = this.createResource(scope)!;        
+    }
+
+    protected createResource(scope: Construct): RequestAuthorizer[] | null {
+        
+        const authorizer = createAuthorizer(scope, this.config, this.layers, this.tables);
+        
+        return [authorizer];
+        
+    }
+
+    protected createOutput<T>(scope: Construct, createdAssets: T[]): void {
+        createdAssets?.forEach((asset) => {
+            if (asset instanceof RequestAuthorizer) {
+                // Output the ARN of the authorizer
+                new CfnOutput(scope, "RequestAuthorizerArn", {
+                    value: `${asset.authorizationType}:${asset.authorizerArn}`
+                });
+            }
+        });
+    }
 }