@byaga/cdk-patterns 0.7.0 → 0.8.1

package/src/FunctionIntegration.ts

@@ -0,0 +1,83 @@
+import {DeployStack} from "./DeployStack";
+import {Function, FunctionProps} from "aws-cdk-lib/aws-lambda";
+import {
+    JsonSchema,
+    LambdaIntegration,
+    MethodOptions,
+    Model,
+    RequestValidator,
+    IResource
+} from "aws-cdk-lib/aws-apigateway";
+import {CfnOutput, Duration} from "aws-cdk-lib";
+import {applyHoneycombToLambda} from "./methods/apply-honeycomb-to-lambda";
+import {RetentionDays} from "aws-cdk-lib/aws-logs";
+import {RestApi} from "./RestApi";
+
+interface AddToApiOptions {
+    requestSchema?: JsonSchema,
+    methodOptions?: MethodOptions
+}
+
+export interface FunctionIntegrationProps {
+    funcProps: FunctionProps,
+    timeout?: Duration
+    memory?: number
+}
+
+export class FunctionIntegration extends Function {
+    stack: DeployStack
+    name: string
+
+    constructor(stack: DeployStack, id: string, options: FunctionIntegrationProps) {
+        const props = applyHoneycombToLambda(stack, {
+            functionName: stack.genName(id),
+            memorySize: options.memory || 256,
+            timeout: options.timeout || Duration.seconds(16),
+            logRetention: RetentionDays.ONE_WEEK,
+            ...options.funcProps
+        })
+
+        super(stack, stack.genId(id, 'lambda'), props);
+        this.stack = stack;
+        this.name = id;
+        stack.set('lambda', id, this)
+        new CfnOutput(stack, stack.genId(id, 'function-name'), {
+            value: this.functionName,
+            exportName: stack.genName(id, 'function-name')
+        });
+    }
+
+    attach(api: RestApi, httpMethod: string, path: string, props?: AddToApiOptions) {
+        const resource: IResource = api.path(path)
+        const integration = new LambdaIntegration(this, {
+            requestTemplates: {
+                'application/json': '{ "statusCode": "200" }'
+            }
+        })
+
+        let options: MethodOptions = props?.methodOptions || {}
+        const schema = props?.requestSchema
+        if (schema) options = applySchema(this.stack, this.name, schema, options, resource)
+
+        const method = resource.addMethod(httpMethod, integration, options)
+    }
+}
+
+function applySchema(stack: DeployStack, name: string, schema: JsonSchema, options: MethodOptions, path: IResource): MethodOptions {
+    return {
+        ...options,
+        requestValidator: new RequestValidator(stack, stack.genId(name, 'validator'), {
+            restApi: path.api,
+            requestValidatorName: stack.genName(name, 'validator'),
+            validateRequestBody: true
+        }),
+        requestModels: {
+            'application/json': new Model(stack, stack.genId(name, 'model'), {
+                schema: schema,
+                contentType: 'application/json',
+                restApi: path.api,
+                modelName: stack.genId(name, 'model')
+            })
+        }
+    }
+}

package/src/ICorsConfig.ts

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

package/src/NodeJsLambda.ts

@@ -0,0 +1,31 @@
+import {Code, FunctionOptions, Runtime} from "aws-cdk-lib/aws-lambda"
+import {DeployStack} from "./DeployStack";
+import {FunctionIntegration} from "./FunctionIntegration";
+import {buildNodeSource} from "./methods/build-node-source";
+import {Duration} from "aws-cdk-lib";
+import duration from "./methods/duration";
+
+interface NodeFunctionProps {
+    funcProps?: FunctionOptions
+    timeout?: Duration
+    memory?: number
+}
+
+export class NodeJsLambda extends FunctionIntegration {
+    constructor(stack: DeployStack, id: string, options?: NodeFunctionProps) {
+        console.log('Defining Node Lambda', id)
+        const done = duration()
+        const {buildDir} = buildNodeSource('lambda', id)
+        console.log('Total Build Duration (ms)', done())
+
+        super(stack, id, {
+            ...options,
+            funcProps: {
+                ...options?.funcProps,
+                code: Code.fromAsset(buildDir),
+                handler: `${id}.handler`,
+                runtime: Runtime.NODEJS_18_X
+            }
+        })
+    }
+}

package/src/NodeJsLambdaLayer.ts

@@ -0,0 +1,27 @@
+import {Code, LayerVersion, Runtime} from "aws-cdk-lib/aws-lambda";
+import {IDeployStack} from "./IDeployStack";
+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 NodeJsLambdaLayerProps extends LayerVersionOptions {
+    readonly compatibleRuntimes?: Runtime[];
+    readonly compatibleArchitectures?: Architecture[];
+}
+
+export class NodeJsLambdaLayer extends LayerVersion {
+    constructor(stack: IDeployStack, id: string, props: NodeJsLambdaLayerProps = {}) {
+        console.log("Building Lambda Layer", id);
+        const done = duration()
+        const buildDir = buildNodeSource('lambda-layer', id, 'nodejs')
+        console.log('Build Duration (ms)', done())
+
+        super(stack, stack.genId(id), {
+            ...props,
+            layerVersionName: stack.genName(id),
+            code: Code.fromAsset(buildDir)
+        });
+        stack.set('lambda-layer', id, this)
+    }
+}

package/src/RestApi.ts

@@ -0,0 +1,178 @@
+import {
+    RestApi as RestApiBase,
+    BasePathMapping,
+    ContentHandling,
+    DomainName,
+    EndpointType,
+    MockIntegration,
+    IDomainName,
+    IResource
+} 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,
+            deployOptions: {
+                stageName: stage,
+                tracingEnabled: true
+            },
+            minCompressionSize: Size.bytes(1000),
+            endpointConfiguration: {
+                types: [EndpointType.EDGE]
+            },
+            defaultCorsPreflightOptions: {
+                allowHeaders: ['*'],
+                allowMethods: ['*'],
+                allowCredentials: props.allowCredentials,
+                allowOrigins,
+                maxAge: Duration.seconds(cors.maxAge || 86400),
+                exposeHeaders: cors.exposeHeaders || DEFAULT_EXPOSE_HEADERS
+            }
+        })
+        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 MockIntegration({
+            requestTemplates: {
+                "application/json": "{\"statusCode\": 200}"
+            },
+            integrationResponses: [{
+                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())
+{
+"body-json" : $input.json('$'),
+"params" : {
+#foreach($type in $allParams.keySet())
+    #set($params = $allParams.get($type))
+"$type" : {
+    #foreach($paramName in $params.keySet())
+    "$paramName" : "$util.escapeJavaScript($params.get($paramName))"
+        #if($foreach.hasNext),#end
+    #end
+}
+    #if($foreach.hasNext),#end
+#end
+},
+"stage-variables" : {
+#foreach($key in $stageVariables.keySet())
+"$key" : "$util.escapeJavaScript($stageVariables.get($key))"
+    #if($foreach.hasNext),#end
+#end
+},
+"context" : {
+    "account-id" : "$context.identity.accountId",
+    "api-id" : "$context.apiId",
+    "api-key" : "$context.identity.apiKey",
+    "authorizer-principal-id" : "$context.authorizer.principalId",
+    "caller" : "$context.identity.caller",
+    "cognito-authentication-provider" : "$context.identity.cognitoAuthenticationProvider",
+    "cognito-authentication-type" : "$context.identity.cognitoAuthenticationType",
+    "cognito-identity-id" : "$context.identity.cognitoIdentityId",
+    "cognito-identity-pool-id" : "$context.identity.cognitoIdentityPoolId",
+    "http-method" : "$context.httpMethod",
+    "stage" : "$context.stage",
+    "source-ip" : "$context.identity.sourceIp",
+    "user" : "$context.identity.user",
+    "user-agent" : "$context.identity.userAgent",
+    "user-arn" : "$context.identity.userArn",
+    "request-id" : "$context.requestId",
+    "resource-id" : "$context.resourceId",
+    "resource-path" : "$context.resourcePath"
+    }
+}`
+                }
+            }]
+        }), {
+            methodResponses: [{statusCode: "200"}]
+        })
+
+        this._tree = {node: this.root, children: {}}
+    }
+
+    addBasePathMapping(stack: DeployStack, config: IBasePathMappingConfig) {
+        let domain = config.domain
+        if (!domain && config.domainName && config.hostedZoneId) {
+            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 BasePathMapping(stack, stack.genId(this._id, 'base-path-mapping'), {
+            domainName: domain,
+            stage: this.deploymentStage,
+            restApi: this,
+            basePath: this._id
+        })
+    }
+
+    addAuthorizedRole(stack: DeployStack, roleArn: string): PolicyStatement {
+        const policyStatement = new PolicyStatement({
+            effect: Effect.ALLOW,
+            actions: ['execute-api:Invoke']
+        })
+
+        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: string): IResource {
+        const {node} = uri.split('/').reduce((resource, path) => {
+            if (!resource.children[path]) {
+                resource.children[path] = {
+                    children: {},
+                    node: resource.node.addResource(path)
+                }
+            }
+            return resource.children[path];
+        }, this._tree);
+
+        return node
+    }
+}

package/src/SsmParameter.ts

@@ -0,0 +1,47 @@
+import {DeployStack} from "./DeployStack";
+import {IStringParameter, StringParameter} from "aws-cdk-lib/aws-ssm";
+import {Effect, IGrantable, PolicyStatement} from "aws-cdk-lib/aws-iam";
+import {IKey} from "aws-cdk-lib/aws-kms";
+
+const paramCache: { [name: string]: IStringParameter } = {}
+
+interface SsmParameterOptions {
+    decryptWithKey?: IKey
+}
+
+export class SsmParameter {
+    parameterName: string
+    parameterArn: string
+    decryptWithKey?: IKey
+    _stack: DeployStack
+
+    constructor(stack: DeployStack, name: string, options?: SsmParameterOptions) {
+        if (name[0] !== '/') name = '/' + name
+        this.parameterName = `/${stack.name}${name}`;
+        this.parameterArn = `arn:aws:ssm:${stack.region}:${stack.account}:parameter${this.parameterName}`
+        this._stack = stack;
+        this.decryptWithKey = options?.decryptWithKey
+    }
+
+    grantRead(grantee: IGrantable) {
+        grantee.grantPrincipal.addToPrincipalPolicy(new PolicyStatement({
+            effect: Effect.ALLOW,
+            actions: ['ssm:GetParameter'],
+            resources: [this.parameterArn]
+        }))
+        if (this.decryptWithKey) {
+            this.decryptWithKey.grantDecrypt(grantee)
+        }
+    }
+
+    get stringValue() {
+        return this.getParameter().stringValue
+    }
+
+    getParameter() {
+        if (!paramCache[this.parameterArn]) {
+            paramCache[this.parameterArn] = StringParameter.fromStringParameterName(this._stack, this._stack.genId(this.parameterName.substring(1).replace('/', '_')), this.parameterName)
+        }
+        return paramCache[this.parameterArn]
+    }
+}

package/src/index.ts

@@ -1,8 +1,14 @@
 export {ApiCertificate} from "./ApiCertificate";
 export {DeployStack} from "./DeployStack";
-export {IDomainConfig} from "./IDomainConfig";
+export {DynamoDbTable} from "./DynamoDbTable";
+export {FunctionIntegration} from "./FunctionIntegration";
 export {IHostedZoneConfig} from "./IHostedZoneConfig";
+export {IDomainConfig} from "./IDomainConfig";
 export {IStackArguments} from "./IStackArguments";
-export {Role} from "./Role";
-export {StaticWebSite} from "./StaticWebSite";
+export {NodeJsLambda} from "./NodeJsLambda";
+export {NodeJsLambdaLayer} from "./NodeJsLambdaLayer";
 export {Output} from "./Output";
+export {RestApi} from "./RestApi";
+export {Role} from "./Role";
+export {SsmParameter} from "./SsmParameter";
+export {StaticWebSite} from "./StaticWebSite";

package/src/methods/apply-honeycomb-to-lambda.ts

@@ -0,0 +1,22 @@
+import {FunctionProps, ILayerVersion, LayerVersion} from "aws-cdk-lib/aws-lambda"
+import {DeployStack} from "../DeployStack";
+import {SsmParameter} from "../SsmParameter";
+
+let honeyCombLayer: ILayerVersion
+export function applyHoneycombToLambda(stack: DeployStack, props: FunctionProps): FunctionProps {
+    if (!honeyCombLayer) honeyCombLayer = LayerVersion.fromLayerVersionArn(stack, stack.genId('hc-layer'), `arn:aws:lambda:${stack.region}:702835727665:layer:honeycomb-lambda-extension-x86_64-v11-1-1:1`)
+
+    const layers = props.layers ? [...props.layers] : []
+    const environment = props.environment || {}
+
+    layers.push(honeyCombLayer)
+    environment.LIBHONEY_API_KEY = new SsmParameter(stack, `/honeycomb/api-key`).stringValue
+    environment.LIBHONEY_DATASET =new SsmParameter(stack, `/honeycomb/dataset`).stringValue
+    environment.LOGS_API_DISABLE_PLATFORM_MSGS = "true"
+
+    return {
+        ...props,
+        layers,
+        environment
+    }
+}

package/src/methods/build-node-source.ts

@@ -0,0 +1,97 @@
+import * as path from 'path'
+import * as fse from "fs-extra";
+import * as fs from "fs";
+import {execSync} from "child_process";
+import {generateHash, HashResult} from "./generate-hash"
+import {getBuildDirectory, getSourceDirectory} from './get-source-directory'
+import duration from "./duration";
+import emptyDirSync from './empty-directory'
+import {IIgnoreOptions} from "./walk-directory";
+
+const distributionRoot = path.resolve(process.cwd(), "../dist")
+const hashRoot = path.join(distributionRoot, "hash")
+fse.ensureDirSync(hashRoot)
+
+export const defaultIgnore: IIgnoreOptions = {
+    included: (p: fs.Dirent): boolean => {
+        return !p.name.startsWith(".") &&
+            !p.name.endsWith(".md") &&
+            !p.name.includes(".test.") &&
+            p.name !== 'package-lock.json';
+    },
+    childrenIncluded: (p: fs.Dirent): boolean => {
+        return p.name === "node_modules";
+    }
+} as IIgnoreOptions
+
+interface IBuildOptions {
+    dir?: string,
+    ignore?: IIgnoreOptions
+}
+
+export function buildNodeSource(type: string, id: string, options: IBuildOptions = {}): {
+    buildDir: string,
+    moduleChanged: boolean,
+    packageChanged: boolean,
+    sourceChanged: boolean
+} {
+    const {dir = ''} = options
+    const ignore = {
+        ...defaultIgnore, ...options.ignore
+    }
+    const srcDir = getSourceDirectory(type, id)
+    const buildDir = getBuildDirectory(type, id)
+    const hashFilePath = path.join(hashRoot, `${type}-${id}-hash.txt`)
+
+    const folderExists = fs.existsSync(buildDir)
+    const hashFileExists = folderExists && fse.existsSync(hashFilePath)
+    const prevHash: HashResult = (hashFileExists ? fse.readJsonSync(hashFilePath) : {}) as HashResult
+    const hash: string = generateHash(srcDir, {ignore});
+    const nextHash: HashResult = JSON.parse(generateHash(srcDir, {ignore})) as HashResult;
+    const moduleChanged = JSON.stringify(prevHash, null, '\t') !== hash;
+    let packageChanged = false, sourceChanged = false;
+
+    if (moduleChanged) {
+        const prevPackageHash = findPackageHash(prevHash);
+        const packageHash = findPackageHash(nextHash);
+        packageChanged = prevPackageHash !== packageHash;
+
+        sourceChanged = sourceWasUpdated(prevHash, nextHash);
+        if (sourceChanged) {
+            const rmComplete = duration()
+            if (folderExists) emptyDirSync(buildDir, {childrenExcluded: folder => folder.name === 'node_modules'})
+            console.log('Cleanup Duration (ms)', rmComplete())
+
+            const copyComplete = duration()
+            fse.copySync(srcDir, buildDir, {
+                filter: src => !~src.indexOf("node_modules") && !src.endsWith('.test.js')
+            });
+            console.log('Copy Duration (ms)', copyComplete())
+        }
+
+        if (packageChanged) {
+            const installComplete = duration()
+            execSync("npm i --omit=dev --omit=optional --omit=peer --quite", {
+                cwd: dir ? path.resolve(buildDir, dir) : buildDir
+            });
+            console.log('NPM Install Duration (ms)', installComplete())
+        }
+        fs.writeFileSync(hashFilePath, hash);
+    }
+
+    return {buildDir, packageChanged, sourceChanged, moduleChanged}
+}
+
+function findPackageHash(hash: HashResult): string | undefined {
+    return hash?.children?.find(file => file.name === 'package.json')?.hash;
+}
+
+function sourceWasUpdated(prevHash: HashResult, nextHash: HashResult): boolean {
+    const fileCountChanged = prevHash.children?.length != nextHash.children?.length
+    const updatedItem = prevHash.children?.find(prevFile => {
+        const nextFile = nextHash.children?.find(f => f.name = prevFile.name);
+        return prevFile.name !== 'package.json' && (!nextFile || nextFile.hash !== prevFile.hash)
+    });
+
+    return fileCountChanged || !!updatedItem
+}

package/src/methods/duration.ts

@@ -0,0 +1,24 @@
+const hrDuration = () => {
+    const startTime: [number, number] = process.hrtime();
+    const onEnd = function duration(): number {
+        const hrTime:[number, number] = process.hrtime(startTime);
+        return hrTime[0] * 1000 + hrTime[1] / 1000000;
+    };
+    onEnd.time = startTime;
+
+    return onEnd;
+};
+const msDuration = () => {
+    const startTime: number = Date.now();
+    const onEnd = function duration(): number {
+        return Date.now() - startTime;
+    };
+    onEnd.time = startTime;
+
+    return onEnd;
+};
+
+// @ts-ignore
+const duration= process.hrtime ? hrDuration : msDuration
+
+export default duration

package/src/methods/empty-directory.ts

@@ -0,0 +1,19 @@
+import * as fse from "fs-extra";
+import duration from "./duration";
+import walkDirectory, {DirentExtended, IIgnoreOptions} from "./walk-directory";
+
+export default function emptyDirSync(parentFolder: string, options: IIgnoreOptions) {
+    const rmComplete = duration()
+    const files = walkDirectory(parentFolder, options);
+
+    files
+        .forEach((file:DirentExtended) => {
+            try {
+                fse.removeSync(file.fullpath());
+                console.log('Deleted file:', file.fullpath());
+            } catch (err) {
+                console.error('Error deleting file:', err);
+            }
+        });
+    console.log('Empty Directory Complete (ms)', parentFolder, rmComplete())
+}

package/src/methods/generate-hash.ts

@@ -0,0 +1,49 @@
+import * as crypto from 'crypto'
+import * as path from 'path'
+import * as fs from 'fs'
+import walk, {IIgnoreOptions} from './walk-directory'
+
+const ALGO = 'sha1';
+const ENCODING = 'base64';
+
+interface HashOptions {
+    ignore: IIgnoreOptions
+}
+
+export interface HashResult {
+    hash?: string
+    children?: HashItem[]
+}
+export interface HashItem {
+    hash: string,
+    path: string,
+    name: string
+}
+
+export function generateHash(folder: string, opt: HashOptions): string {
+    const files = walk(folder, opt.ignore);
+
+    const hash = crypto.createHash(ALGO);
+    const children = files
+        .sort((a, b) => a.fullpath().localeCompare(b.fullpath()))
+        .map((child) => {
+            const relPath = path.relative(process.cwd(), child.fullpath())
+            const fileHash = crypto.createHash(ALGO);
+            fileHash.update(relPath);
+            fileHash.update(fs.readFileSync(child.fullpath()));
+
+            const file = {
+                name: child.name,
+                path: relPath,
+                hash: fileHash.digest(ENCODING)
+            };
+            hash.update(file.hash);
+
+            return file;
+        });
+
+    return JSON.stringify({
+        hash: hash.digest(ENCODING),
+        children
+    }, null, '\t')
+}

package/src/methods/get-source-directory.ts

@@ -0,0 +1,11 @@
+import * as path from 'path'
+
+export const sourceRoot = path.resolve(process.cwd(), "../src");
+export const distributionRoot = path.resolve(process.cwd(), "../dist");
+
+export function getSourceDirectory(type: string, id: string): string {
+    return path.join(sourceRoot, type, id)
+}
+export function getBuildDirectory(type: string, id: string): string {
+    return path.join(distributionRoot, type, id)
+}

package/src/methods/walk-directory.ts

@@ -0,0 +1,30 @@
+import * as path from 'path'
+import * as fs from 'fs'
+
+export interface IIgnoreOptions {
+    excluded?: (stat: fs.Dirent) => boolean,
+    included?: (stat: fs.Dirent) => boolean,
+    childrenExcluded?: (stat: fs.Dirent) => boolean,
+    childrenIncluded?: (stat: fs.Dirent) => boolean
+}
+export const yes = () => true
+export const no = () => false
+
+export default function walkDirectory(directory: string, options: IIgnoreOptions, filepaths: DirentExtended[] = []): DirentExtended[] {
+    const { excluded = no, included = yes, childrenExcluded = no, childrenIncluded = yes} = options;
+    const files = fs.readdirSync(directory, {withFileTypes: true}) as unknown[] as DirentExtended[];
+    for (let stats of files) {
+        const filepath = path.join(directory, stats.name)
+        stats.fullpath = () => filepath
+        if (stats.isDirectory() && !childrenExcluded(stats) && childrenIncluded(stats)) {
+            walkDirectory(filepath, options, filepaths)
+        } else if (stats.isFile() && !excluded(stats) && included(stats)) {
+            filepaths.push(stats)
+        }
+    }
+    return filepaths;
+}
+
+export interface DirentExtended extends fs.Dirent {
+    fullpath: () => string
+}