@byaga/cdk-patterns 0.10.0 → 0.11.1

package/README.md

@@ -26,7 +26,13 @@ Then, you can use the patterns provided by the package in your CDK stacks.
 
 The package includes the following patterns:
 
-- [NodeJsLambda](./src/NodeJsLambda.md)
+- [createStack](./src/create-stack.md)
+- [createNodeJsLambda](./src/create-nodejs-lambda.md)
+
+And the below helpful functions:
+
+- [Building Code](./src/build-code.md)
+- [Generating Identifiers](./src/generate-identifier.md)
 
 ## Contributing
 

package/archive/ApiAttachPoint.ts

@@ -0,0 +1,9 @@
+import {  Method } from "aws-cdk-lib/aws-apigateway";
+
+/**
+ * Interface for the API attach point.
+ */
+export interface ApiAttachPoint {
+    method: Method
+    resourceArn: string
+}

package/archive/ApiCertificate.ts

@@ -0,0 +1,32 @@
+import {Certificate, CertificateValidation} from "aws-cdk-lib/aws-certificatemanager";
+import {HostedZone, IHostedZone} from "aws-cdk-lib/aws-route53";
+import {Output} from "./Output";
+import DeployStack from "./DeployStack";
+import IDomainConfig from "./IDomainConfig";
+
+export class ApiCertificate extends Certificate {
+    hostedZone: IHostedZone
+    domain: string
+
+    constructor(stack: DeployStack, id: string, domain: IDomainConfig) {
+        const certDomain = [domain.domainName]
+        if (domain.subdomain) certDomain.splice(0, 0, domain.subdomain)
+        const domainName = certDomain.join('.')
+
+        console.log('Getting Hosted Zone', domain.hostedZone.name)
+        const hostedZone: IHostedZone = HostedZone.fromHostedZoneAttributes(stack, stack.genId(id, 'hosted-zone'), {
+            hostedZoneId: domain.hostedZone.id,
+            zoneName: domain.hostedZone.name
+        })
+        console.log('Defining Certificate For', domainName)
+        super(stack, stack.genId(id), {
+            domainName,
+            validation: CertificateValidation.fromDns(hostedZone)
+        });
+
+        this.domain = domainName
+        new Output(stack, id, this.certificateArn)
+        this.hostedZone = hostedZone
+    }
+}
+export default ApiCertificate

package/{lib/CognitoApiGatewayAuthorizer.d.ts → archive/CognitoApiGatewayAuthorizer.ts}

@@ -1,6 +1,7 @@
-import { Construct } from 'constructs';
-import { CfnAuthorizer, IAuthorizer } from 'aws-cdk-lib/aws-apigateway';
-import { CfnAuthorizerProps } from 'aws-cdk-lib/aws-apigateway/lib/apigateway.generated';
+import { Construct } from 'constructs'
+import { CfnAuthorizer, IAuthorizer } from 'aws-cdk-lib/aws-apigateway'
+import { CfnAuthorizerProps } from 'aws-cdk-lib/aws-apigateway/lib/apigateway.generated'
+
 /**
  * Custom construct that implements a Cognito based API Gateway Authorizer.
  *
@@ -13,7 +14,12 @@ import { CfnAuthorizerProps } from 'aws-cdk-lib/aws-apigateway/lib/apigateway.ge
  *
  * @see https://github.com/aws/aws-cdk/issues/5618#issuecomment-666922559
  */
-export declare class CognitoApiGatewayAuthorizer extends CfnAuthorizer implements IAuthorizer {
-    readonly authorizerId: string;
-    constructor(scope: Construct, id: string, props: CfnAuthorizerProps);
-}
+export class CognitoApiGatewayAuthorizer extends CfnAuthorizer implements IAuthorizer {
+    public readonly authorizerId: string
+
+    constructor(scope: Construct, id: string, props: CfnAuthorizerProps) {
+        super(scope, id, props)
+
+        this.authorizerId = this.ref
+    }
+}

package/archive/DynamoDbTable.ts

@@ -0,0 +1,40 @@
+import {CfnOutput, RemovalPolicy} from 'aws-cdk-lib';
+import {Table, BillingMode, AttributeType} from 'aws-cdk-lib/aws-dynamodb'
+import {Effect, Policy, PolicyStatement} from "aws-cdk-lib/aws-iam";
+import {DeployStack} from "./DeployStack"
+
+interface DynamoDbTableConfig {
+    partitionKey: string,
+    sortKey?: string
+}
+
+export class DynamoDbTable extends Table {
+    getPolicy: Policy
+
+    constructor(stack: DeployStack, id: string, props: DynamoDbTableConfig) {
+        console.log('Creating DynamoDb Table', stack.genName(id, 'data-table'))
+        super(stack, stack.genId(id, 'data-table'), {
+            tableName: stack.genName(id, 'data-table'),
+            partitionKey: {name: props.partitionKey, type: AttributeType.STRING},
+            sortKey: props.sortKey ? {name: props.sortKey, type: AttributeType.STRING} : undefined,
+            billingMode: BillingMode.PAY_PER_REQUEST,
+            removalPolicy: RemovalPolicy.DESTROY
+        });
+    stack.set('dynamo', id, this)
+
+        new CfnOutput(stack, stack.genId(id, 'table'), {
+            value: this.tableName,
+            exportName: stack.genName(id, 'table')
+        })
+
+        this.getPolicy = new Policy(stack, stack.genId(id, 'get-policy'), {
+            statements: [
+                new PolicyStatement({
+                    actions: ['dynamodb:GetItem'],
+                    effect: Effect.ALLOW,
+                    resources: [this.tableArn]
+                })
+            ]
+        })
+    }
+}

package/archive/ICorsConfig.ts

@@ -0,0 +1,5 @@
+export interface ICorsConfig {
+    maxAge?: number
+    exposeHeaders?: string[],
+    allowOrigin?: string|string[]
+}

package/archive/IDomainConfig.ts

@@ -0,0 +1,8 @@
+import IHostedZoneConfig from "./IHostedZoneConfig";
+
+export interface IDomainConfig {
+    domainName: string,
+    subdomain?: string,
+    hostedZone: IHostedZoneConfig
+}
+export default IDomainConfig

package/archive/IHostedZoneConfig.ts

@@ -0,0 +1,5 @@
+export interface IHostedZoneConfig {
+    name: string,
+    id: string
+}
+export default IHostedZoneConfig

package/archive/NodeJsLambdaLayer.ts

@@ -0,0 +1,42 @@
+import {Code, LayerVersion, Runtime} from "aws-cdk-lib/aws-lambda";
+import {DeployStack} from "./DeployStack";
+import {LayerVersionOptions} from "aws-cdk-lib/aws-lambda/lib/layers";
+import {Architecture} from "aws-cdk-lib/aws-lambda/lib/architecture";
+import {buildNodeSource} from "./methods/build-node-source";
+import duration from "./methods/duration";
+
+/**
+ * Interface for the properties of the NodeJsLambdaLayer class.
+ */
+interface NodeJsLambdaLayerProps extends LayerVersionOptions {
+    readonly compatibleRuntimes?: Runtime[];
+    readonly compatibleArchitectures?: Architecture[];
+}
+
+/**
+ * Class representing a Node.js AWS Lambda layer.
+ * Extends the LayerVersion class from the AWS CDK library.
+ */
+export class NodeJsLambdaLayer extends LayerVersion {
+    /**
+     * Constructs a new NodeJsLambdaLayer instance.
+     * @param {DeployStack} stack - The deployment stack.
+     * @param {string} id - The ID of the layer.
+     * @param {NodeJsLambdaLayerProps} props - The properties of the layer.
+     */
+    constructor(stack: DeployStack, id: string, props: NodeJsLambdaLayerProps = {}) {
+        console.log("Building Lambda Layer", id);
+        const done = duration()
+        const buildDir = buildNodeSource('lambda-layer', id, {subdirectory:'nodejs'})
+        console.log('Build Duration (ms)', done())
+
+        super(stack, stack.genId(id), {
+            compatibleRuntimes: [Runtime.NODEJS_20_X],
+            ...props,
+            layerVersionName: stack.genName(id),
+            code: Code.fromAsset(buildDir),
+
+        });
+        stack.set('lambda-layer', id, this)
+    }
+}

package/archive/Output.ts

@@ -0,0 +1,11 @@
+import {CfnOutput} from 'aws-cdk-lib/core';
+import {DeployStack} from './DeployStack';
+
+export class Output extends CfnOutput {
+    constructor(stack: DeployStack, name: string, value: string) {
+        super(stack, stack.genId(name, 'output'), {
+            value,
+            exportName: stack.genName(name)
+        })
+    }
+}

package/{lib/RestApi.js → archive/RestApi.ts}

@@ -1,18 +1,48 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RestApi = void 0;
-const aws_apigateway_1 = require("aws-cdk-lib/aws-apigateway");
-const aws_cdk_lib_1 = require("aws-cdk-lib");
-const aws_iam_1 = require("aws-cdk-lib/aws-iam");
-const DEFAULT_EXPOSE_HEADERS = ['Date'];
-class RestApi extends aws_apigateway_1.RestApi {
-    _id;
-    _tree;
-    constructor(stack, id, props) {
-        const { stage } = stack;
-        console.log('Defining Rest API', stack.genId(id, 'api'));
-        const cors = props.cors || {};
-        const allowOrigins = Array.isArray(cors.allowOrigin) ? cors.allowOrigin : [cors.allowOrigin || '*'];
+import {
+    BasePathMapping,
+    ContentHandling,
+    DomainName,
+    EndpointType,
+    IDomainName,
+    IResource,
+    MockIntegration,
+    RestApi as RestApiBase
+} from "aws-cdk-lib/aws-apigateway";
+import {DeployStack} from "./DeployStack"
+import {ICorsConfig} from "./ICorsConfig";
+import {Duration, Size} from "aws-cdk-lib";
+import {Effect, Policy, PolicyStatement, Role} from "aws-cdk-lib/aws-iam";
+
+interface IRestApiConfig {
+    cors?: ICorsConfig,
+    allowCredentials: boolean
+}
+
+interface IBasePathMappingConfig {
+    domain?: IDomainName,
+    domainName?: string,
+    hostedZoneId?: string
+}
+
+interface IResourceNode {
+    children: { [key: string]: IResourceNode }
+    node: IResource
+}
+
+const DEFAULT_EXPOSE_HEADERS = ['Date']
+
+export class RestApi extends RestApiBase {
+    _id: string
+    _tree: IResourceNode
+
+
+    constructor(stack: DeployStack, id: string, props: IRestApiConfig) {
+        const {stage} = stack
+
+        console.log('Defining Rest API', stack.genId(id, 'api'))
+
+        const cors: ICorsConfig = props.cors || {}
+        const allowOrigins: string[] = Array.isArray(cors.allowOrigin) ? cors.allowOrigin : [cors.allowOrigin || '*']
         super(stack, stack.genId(id, 'api'), {
             restApiName: stack.genName('api'),
             deploy: true,
@@ -20,32 +50,33 @@ class RestApi extends aws_apigateway_1.RestApi {
                 stageName: stage,
                 tracingEnabled: true
             },
-            minCompressionSize: aws_cdk_lib_1.Size.bytes(1000),
+            minCompressionSize: Size.bytes(1000),
             endpointConfiguration: {
-                types: [aws_apigateway_1.EndpointType.EDGE]
+                types: [EndpointType.EDGE]
             },
             defaultCorsPreflightOptions: {
                 allowHeaders: ['*'],
                 allowMethods: ['*'],
                 allowCredentials: props.allowCredentials,
                 allowOrigins,
-                maxAge: aws_cdk_lib_1.Duration.seconds(cors.maxAge || 86400),
+                maxAge: Duration.seconds(cors.maxAge || 86400),
                 exposeHeaders: cors.exposeHeaders || DEFAULT_EXPOSE_HEADERS
             }
-        });
-        this._id = id;
+        })
+        this._id = id
+
         // APIs MUST have at least one endpoint, so this will give it one
-        console.log('Adding health endpoint', '/health');
-        const health = this.root.addResource('health');
-        health.addMethod("GET", new aws_apigateway_1.MockIntegration({
+        console.log('Adding health endpoint', '/health')
+        const health = this.root.addResource('health')
+        health.addMethod("GET", new MockIntegration({
             requestTemplates: {
                 "application/json": "{\"statusCode\": 200}"
             },
             integrationResponses: [{
-                    statusCode: '200',
-                    contentHandling: aws_apigateway_1.ContentHandling.CONVERT_TO_TEXT,
-                    responseTemplates: {
-                        'application/json': `
+                statusCode: '200',
+                contentHandling: ContentHandling.CONVERT_TO_TEXT,
+                responseTemplates: {
+                    'application/json': `
 ##  See http://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-mapping-template-reference.html
 ##  This template will pass through all parameters including path, querystring, header, stage variables, and context through to the integration endpoint via the body/payload
 #set($allParams = $input.params())
@@ -90,55 +121,60 @@ class RestApi extends aws_apigateway_1.RestApi {
     "resource-path" : "$context.resourcePath"
     }
 }`
-                    }
-                }]
+                }
+            }]
         }), {
-            methodResponses: [{ statusCode: "200" }]
-        });
-        this._tree = { node: this.root, children: {} };
+            methodResponses: [{statusCode: "200"}]
+        })
+
+        this._tree = {node: this.root, children: {}}
     }
-    addBasePathMapping(stack, config) {
-        let domain = config.domain;
+
+    addBasePathMapping(stack: DeployStack, config: IBasePathMappingConfig) {
+        let domain = config.domain
         if (!domain && config.domainName && config.hostedZoneId) {
-            domain = aws_apigateway_1.DomainName.fromDomainNameAttributes(stack, stack.genName('domain-name'), {
+            domain = DomainName.fromDomainNameAttributes(stack, stack.genName('domain-name'), {
                 domainName: config.domainName,
                 domainNameAliasHostedZoneId: config.hostedZoneId,
                 domainNameAliasTarget: this.restApiRootResourceId
-            });
+            })
         }
-        if (!domain)
-            throw new Error('Missing Domain Configuration For Base Path Mapping');
-        new aws_apigateway_1.BasePathMapping(stack, stack.genId(this._id, 'base-path-mapping'), {
+        if (!domain) throw new Error('Missing Domain Configuration For Base Path Mapping')
+
+        new BasePathMapping(stack, stack.genId(this._id, 'base-path-mapping'), {
             domainName: domain,
             stage: this.deploymentStage,
             restApi: this,
             basePath: this._id
-        });
+        })
     }
-    addAuthorizedRole(stack, roleArn) {
-        const policyStatement = new aws_iam_1.PolicyStatement({
-            effect: aws_iam_1.Effect.ALLOW,
+
+    addAuthorizedRole(stack: DeployStack, roleArn: string): PolicyStatement {
+        const policyStatement = new PolicyStatement({
+            effect: Effect.ALLOW,
             actions: ['execute-api:Invoke']
-        });
-        const authRole = aws_iam_1.Role.fromRoleArn(stack, stack.genId('authenticated-role'), roleArn);
-        authRole.attachInlinePolicy(new aws_iam_1.Policy(stack, stack.genId('api-access-policy'), {
+        })
+
+        const authRole = Role.fromRoleArn(stack, stack.genId('authenticated-role'), roleArn)
+        authRole.attachInlinePolicy(new Policy(stack, stack.genId('api-access-policy'), {
             statements: [policyStatement]
-        }));
+        }))
         return policyStatement;
     }
-    path(uri) {
-        const { node } = uri.split('/')
+
+    path(uri: string): IResource {
+        const {node} = uri.split('/')
             .filter(path => !!path)
             .reduce((resource, path) => {
-            if (!resource.children[path]) {
-                resource.children[path] = {
-                    children: {},
-                    node: resource.node.addResource(path)
-                };
-            }
-            return resource.children[path];
-        }, this._tree);
-        return node;
+                if (!resource.children[path]) {
+                    resource.children[path] = {
+                        children: {},
+                        node: resource.node.addResource(path)
+                    }
+                }
+                return resource.children[path];
+            }, this._tree);
+
+        return node
     }
-}
-exports.RestApi = RestApi;
+}