@sylvesterllc/aws-constructs 1.1.37 → 1.1.39

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-helper.ts

@@ -1,146 +1,124 @@
-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 { LambdaProps } from "../../interfaces/lambda";
-import { Construct } from "constructs";
-import { Table } from "aws-cdk-lib/aws-dynamodb";
-
-export const createBasicLambda = (
-  scope: Construct,
-  props: LambdaProps
-): NodejsFunction => {
-  const lambdaProps = createBasicLambdaProps(props);
-
-  const functionName = `${props.appPrefix || ""}${props.functionName}`;
-
-  let lambdaFunction = new NodejsFunction(scope, functionName, lambdaProps);
-
-  grantAccessToDynamoTables(
-    scope,
-    lambdaFunction,
-    functionName,
-    props.dynamoTableNames
-  );
-
-  addLambdaLayers(scope, lambdaFunction, functionName, props.lambdaLayerArn);
-
-  return lambdaFunction;
-};
-
-const createBasicLambdaProps = (props: LambdaProps): NodejsFunctionProps => {
-  let resolvedEntry: string;
-  let depsLockFilePath: string | undefined = props.depsLockFilePath;
-
-  if (props.codePath && path.isAbsolute(props.codePath)) {
-    resolvedEntry = props.codePath;
-  } else if (props.codePath && props.projectRoot) {
-    // codePath is relative, resolve from current directory + projectRoot
-    resolvedEntry = path.resolve(process.cwd(), props.codePath);
-  } else if (props.projectRoot) {
-    // No codePath, use default path with projectRoot
-    resolvedEntry = path.resolve(
-      process.cwd(),
-      props.projectRoot,
-      `resources/lambdas/${props.functionName}/main.mts`
-    );
-  } else if (props.codePath) {
-    // codePath without projectRoot
-    resolvedEntry = path.resolve(process.cwd(), props.codePath);
-  } else {
-    // Default path without projectRoot
-    resolvedEntry = path.join(
-      `./resources/lambdas/${props.functionName}/main.mts`
-    );
-  }
-
-  // When projectRoot is provided, override depsLockFilePath to point to the projectRoot's lock file
-  if (props.projectRoot && !depsLockFilePath) {
-    const lockFiles = ["pnpm-lock.yaml", "yarn.lock", "package-lock.json"];
-    for (const lockFile of lockFiles) {
-      const lockPath = path.join(props.projectRoot, lockFile);
-      if (require("fs").existsSync(lockPath)) {
-        depsLockFilePath = lockPath;
-        break;
-      }
-    }
-  }
-
-  const lambdaProp: NodejsFunctionProps = {
-    entry: resolvedEntry,
-    functionName: `${props.appPrefix ? `${props.appPrefix}-` : ""}${
-      props.functionName
-    }`,
-    handler: "index.main",
-    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,
-      },
-      ...(props.projectRoot && { projectRoot: props.projectRoot }),
-      ...(depsLockFilePath && {
-        depsLockFilePath: depsLockFilePath,
-      }),
-    },
-    role: props.role,
-    layers: undefined,
-  };
-
-  return lambdaProp;
-};
-
-const grantAccessToDynamoTables = (
-  scope: Construct,
-  lambda: NodejsFunction,
-  functionName: string,
-  tableNames?: string[]
-) => {
-  if (tableNames && tableNames.length > 0) {
-    tableNames.forEach((tableName, idx) => {
-      const table = Table.fromTableName(
-        scope,
-        `${tableName}-table-${idx}`,
-        tableName
-      );
-
-      table.grantReadWriteData(lambda);
-    });
-  }
-};
-
-const addLambdaLayers = (
-  scope: Construct,
-  lambda: NodejsFunction,
-  functionName: string,
-  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);
-    });
-  }
-};
+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 { LambdaProps } from "../../interfaces/lambda";
+import { Construct } from "constructs";
+import { Table } from "aws-cdk-lib/aws-dynamodb";
+
+export const createBasicLambda = (
+  scope: Construct,
+  props: LambdaProps
+): NodejsFunction => {
+  const lambdaProps = createBasicLambdaProps(props);
+
+  let lambdaFunction = new NodejsFunction(
+    scope,
+    `${props.appPrefix || ""}${props.functionName}`,
+    lambdaProps
+  );
+
+  grantAccessToDynamoTables(scope, lambdaFunction, props.dynamoTableNames);
+
+  addLambdaLayers(scope, lambdaFunction, props.lambdaLayerArn);
+
+  return lambdaFunction;
+};
+
+const createBasicLambdaProps = (props: LambdaProps): NodejsFunctionProps => {
+  let resolvedEntry: string;
+
+  if (props.codePath && path.isAbsolute(props.codePath)) {
+    resolvedEntry = props.codePath;
+  } else if (props.codePath && props.projectRoot) {
+    // codePath is relative, resolve from current directory + projectRoot
+    resolvedEntry = path.resolve(process.cwd(), props.codePath);
+  } else if (props.projectRoot) {
+    // No codePath, use default path with projectRoot
+    resolvedEntry = path.resolve(
+      process.cwd(),
+      props.projectRoot,
+      `resources/lambdas/${props.functionName}/main.mts`
+    );
+  } else if (props.codePath) {
+    // codePath without projectRoot
+    resolvedEntry = path.resolve(process.cwd(), props.codePath);
+  } else {
+    // Default path without projectRoot
+    resolvedEntry = path.join(
+      `./resources/lambdas/${props.functionName}/main.mts`
+    );
+  }
+
+  const lambdaProp: NodejsFunctionProps = {
+    entry: resolvedEntry,
+    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,
+      },
+      ...(props.projectRoot && { projectRoot: props.projectRoot }),
+      ...(props.depsLockFilePath && {
+        depsLockFilePath: props.depsLockFilePath,
+      }),
+    },
+    role: props.role,
+    layers: undefined,
+  };
+
+  return lambdaProp;
+};
+
+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);
+    });
+  }
+};