@byaga/cdk-patterns 0.6.1 → 0.8.0

package/lib/StaticWebSite.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import { DeployStack } from "./DeployStack";
+import IDomainConfig from "./IDomainConfig";
+interface StaticWebSiteConfig {
+    srcDir?: string;
+    domain: IDomainConfig;
+    env: NodeJS.ProcessEnv;
+}
+export declare class StaticWebSite {
+    constructor(stack: DeployStack, id: string, props: StaticWebSiteConfig);
+}
+export {};

package/lib/StaticWebSite.js

@@ -0,0 +1,107 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticWebSite = void 0;
+const core_1 = require("aws-cdk-lib/core");
+const Output_1 = require("./Output");
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const aws_s3_1 = require("aws-cdk-lib/aws-s3");
+const aws_s3_deployment_1 = require("aws-cdk-lib/aws-s3-deployment");
+const ApiCertificate_1 = __importDefault(require("./ApiCertificate"));
+const aws_cloudfront_1 = require("aws-cdk-lib/aws-cloudfront");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const aws_route53_1 = require("aws-cdk-lib/aws-route53");
+const aws_route53_targets_1 = require("aws-cdk-lib/aws-route53-targets");
+class StaticWebSite {
+    constructor(stack, id, props) {
+        console.log('Deploying Static Web Site', id);
+        const srcDir = path.resolve("../src/", props.srcDir || '');
+        const buildDir = path.resolve("../dist/", props.srcDir || '');
+        console.log('Installing Prod Dependencies', id);
+        (0, child_process_1.execSync)('npm i --production --quiet', {
+            cwd: srcDir
+        });
+        console.log('Building UI Source', id);
+        (0, child_process_1.execSync)('npm run export', {
+            cwd: srcDir,
+            //env: props.env
+        });
+        fs.copySync(path.resolve(srcDir, "./out"), buildDir);
+        console.log('Creating HTTPS Certificate', id + '-certificate');
+        const certificate = new ApiCertificate_1.default(stack, id + '-certificate', props.domain);
+        console.log('Deploying Site Content Bucket', stack.genId(id, "content-bucket"));
+        const s3BucketSource = new aws_s3_1.Bucket(stack, stack.genId(id, "content-bucket"), {
+            bucketName: certificate.domain,
+            websiteIndexDocument: "index.html",
+            websiteErrorDocument: "error.html",
+            publicReadAccess: true,
+            removalPolicy: core_1.RemovalPolicy.DESTROY,
+            autoDeleteObjects: true
+        });
+        new Output_1.Output(stack, `${id}-content-bucket`, s3BucketSource.bucketName);
+        const cloudFrontPolicy = new aws_iam_1.PolicyStatement({
+            actions: ['s3:GetBucket*', 's3:GetObject*', 's3:List*'],
+            resources: [s3BucketSource.bucketArn, s3BucketSource.bucketArn + '/*'],
+        });
+        new aws_s3_deployment_1.BucketDeployment(stack, stack.genId(id, 'bucket-deployment'), {
+            sources: [aws_s3_deployment_1.Source.asset(buildDir)],
+            destinationBucket: s3BucketSource
+        });
+        const originAccessIdentity = new aws_cloudfront_1.OriginAccessIdentity(stack, "WebsiteOAI");
+        cloudFrontPolicy.addArnPrincipal(originAccessIdentity.cloudFrontOriginAccessIdentityS3CanonicalUserId);
+        const distro = new aws_cloudfront_1.CloudFrontWebDistribution(stack, stack.genId(id, 'cloudfront-web-distribution'), {
+            enabled: true,
+            //priceClass:
+            originConfigs: [{
+                    s3OriginSource: {
+                        s3BucketSource,
+                        originAccessIdentity
+                    },
+                    behaviors: [{
+                            allowedMethods: aws_cloudfront_1.CloudFrontAllowedMethods.GET_HEAD_OPTIONS,
+                            isDefaultBehavior: true
+                        }]
+                }],
+            viewerProtocolPolicy: aws_cloudfront_1.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+            viewerCertificate: aws_cloudfront_1.ViewerCertificate.fromAcmCertificate(certificate, {
+                aliases: [certificate.domain],
+                sslMethod: aws_cloudfront_1.SSLMethod.SNI
+            })
+        });
+        new Output_1.Output(stack, `${id}-base-url`, "https://" + certificate.domain);
+        console.log('Setting Route53 A-Name Record', props.domain.domainName);
+        new aws_route53_1.ARecord(stack, stack.genId('alias'), {
+            zone: certificate.hostedZone,
+            recordName: certificate.domain,
+            target: aws_route53_1.RecordTarget.fromAlias(new aws_route53_targets_1.CloudFrontTarget(distro))
+        });
+    }
+}
+exports.StaticWebSite = StaticWebSite;

package/lib/index.d.ts

@@ -1,6 +1,12 @@
 export { ApiCertificate } from "./ApiCertificate";
-export { IDeployStack } from "./IDeployStack";
+export { DeployStack } from "./DeployStack";
 export { IDomainConfig } from "./IDomainConfig";
 export { IHostedZoneConfig } from "./IHostedZoneConfig";
 export { IStackArguments } from "./IStackArguments";
 export { Role } from "./Role";
+export { StaticWebSite } from "./StaticWebSite";
+export { Output } from "./Output";
+export { RestApi } from "./RestApi";
+export { NodeJsLambda } from "./NodeJsLambda";
+export { DynamoDbTable } from "./DynamoDbTable";
+export { FunctionIntegration } from "./FunctionIntegration";

package/lib/index.js

@@ -1,9 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Role = exports.IDeployStack = exports.ApiCertificate = void 0;
+exports.FunctionIntegration = exports.DynamoDbTable = exports.NodeJsLambda = exports.RestApi = exports.Output = exports.StaticWebSite = exports.Role = exports.DeployStack = exports.ApiCertificate = void 0;
 var ApiCertificate_1 = require("./ApiCertificate");
 Object.defineProperty(exports, "ApiCertificate", { enumerable: true, get: function () { return ApiCertificate_1.ApiCertificate; } });
-var IDeployStack_1 = require("./IDeployStack");
-Object.defineProperty(exports, "IDeployStack", { enumerable: true, get: function () { return IDeployStack_1.IDeployStack; } });
+var DeployStack_1 = require("./DeployStack");
+Object.defineProperty(exports, "DeployStack", { enumerable: true, get: function () { return DeployStack_1.DeployStack; } });
 var Role_1 = require("./Role");
 Object.defineProperty(exports, "Role", { enumerable: true, get: function () { return Role_1.Role; } });
+var StaticWebSite_1 = require("./StaticWebSite");
+Object.defineProperty(exports, "StaticWebSite", { enumerable: true, get: function () { return StaticWebSite_1.StaticWebSite; } });
+var Output_1 = require("./Output");
+Object.defineProperty(exports, "Output", { enumerable: true, get: function () { return Output_1.Output; } });
+var RestApi_1 = require("./RestApi");
+Object.defineProperty(exports, "RestApi", { enumerable: true, get: function () { return RestApi_1.RestApi; } });
+var NodeJsLambda_1 = require("./NodeJsLambda");
+Object.defineProperty(exports, "NodeJsLambda", { enumerable: true, get: function () { return NodeJsLambda_1.NodeJsLambda; } });
+var DynamoDbTable_1 = require("./DynamoDbTable");
+Object.defineProperty(exports, "DynamoDbTable", { enumerable: true, get: function () { return DynamoDbTable_1.DynamoDbTable; } });
+var FunctionIntegration_1 = require("./FunctionIntegration");
+Object.defineProperty(exports, "FunctionIntegration", { enumerable: true, get: function () { return FunctionIntegration_1.FunctionIntegration; } });

package/lib/methods/apply-honeycomb-to-lambda.d.ts

@@ -0,0 +1,3 @@
+import { FunctionProps } from "aws-cdk-lib/aws-lambda";
+import { DeployStack } from "../DeployStack";
+export declare function applyHoneycombToLambda(stack: DeployStack, props: FunctionProps): FunctionProps;

package/lib/methods/apply-honeycomb-to-lambda.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyHoneycombToLambda = void 0;
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const SsmParameter_1 = require("../SsmParameter");
+let honeyCombLayer;
+function applyHoneycombToLambda(stack, props) {
+    if (!honeyCombLayer)
+        honeyCombLayer = aws_lambda_1.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_1.SsmParameter(stack, `/honeycomb/api-key`).stringValue;
+    environment.LIBHONEY_DATASET = new SsmParameter_1.SsmParameter(stack, `/honeycomb/dataset`).stringValue;
+    environment.LOGS_API_DISABLE_PLATFORM_MSGS = "true";
+    return {
+        ...props,
+        layers,
+        environment
+    };
+}
+exports.applyHoneycombToLambda = applyHoneycombToLambda;

package/lib/methods/build-node-source.d.ts

@@ -0,0 +1,13 @@
+import { IIgnoreOptions } from "./walk-directory";
+export declare const defaultIgnore: IIgnoreOptions;
+interface IBuildOptions {
+    dir?: string;
+    ignore?: IIgnoreOptions;
+}
+export declare function buildNodeSource(type: string, id: string, options?: IBuildOptions): {
+    buildDir: string;
+    moduleChanged: boolean;
+    packageChanged: boolean;
+    sourceChanged: boolean;
+};
+export {};

package/lib/methods/build-node-source.js

@@ -0,0 +1,105 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildNodeSource = exports.defaultIgnore = void 0;
+const path = __importStar(require("path"));
+const fse = __importStar(require("fs-extra"));
+const fs = __importStar(require("fs"));
+const child_process_1 = require("child_process");
+const generate_hash_1 = require("./generate-hash");
+const get_source_directory_1 = require("./get-source-directory");
+const duration_1 = __importDefault(require("./duration"));
+const empty_directory_1 = __importDefault(require("./empty-directory"));
+const distributionRoot = path.resolve(process.cwd(), "../dist");
+const hashRoot = path.join(distributionRoot, "hash");
+fse.ensureDirSync(hashRoot);
+exports.defaultIgnore = {
+    included: (p) => {
+        return !p.name.startsWith(".") &&
+            !p.name.endsWith(".md") &&
+            !p.name.includes(".test.") &&
+            p.name !== 'package-lock.json';
+    },
+    childrenIncluded: (p) => {
+        return p.name === "node_modules";
+    }
+};
+function buildNodeSource(type, id, options = {}) {
+    const { dir = '' } = options;
+    const ignore = {
+        ...exports.defaultIgnore, ...options.ignore
+    };
+    const srcDir = (0, get_source_directory_1.getSourceDirectory)(type, id);
+    const buildDir = (0, get_source_directory_1.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 = (hashFileExists ? fse.readJsonSync(hashFilePath) : {});
+    const hash = (0, generate_hash_1.generateHash)(srcDir, { ignore });
+    const nextHash = JSON.parse((0, generate_hash_1.generateHash)(srcDir, { ignore }));
+    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 = (0, duration_1.default)();
+            if (folderExists)
+                (0, empty_directory_1.default)(buildDir, { childrenExcluded: folder => folder.name === 'node_modules' });
+            console.log('Cleanup Duration (ms)', rmComplete());
+            const copyComplete = (0, duration_1.default)();
+            fse.copySync(srcDir, buildDir, {
+                filter: src => !~src.indexOf("node_modules") && !src.endsWith('.test.js')
+            });
+            console.log('Copy Duration (ms)', copyComplete());
+        }
+        if (packageChanged) {
+            const installComplete = (0, duration_1.default)();
+            (0, child_process_1.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 };
+}
+exports.buildNodeSource = buildNodeSource;
+function findPackageHash(hash) {
+    return hash?.children?.find(file => file.name === 'package.json')?.hash;
+}
+function sourceWasUpdated(prevHash, nextHash) {
+    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/lib/methods/duration.d.ts

@@ -0,0 +1,8 @@
+declare const duration: (() => {
+    (): number;
+    time: [number, number];
+}) | (() => {
+    (): number;
+    time: number;
+});
+export default duration;

package/lib/methods/duration.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const hrDuration = () => {
+    const startTime = process.hrtime();
+    const onEnd = function duration() {
+        const hrTime = process.hrtime(startTime);
+        return hrTime[0] * 1000 + hrTime[1] / 1000000;
+    };
+    onEnd.time = startTime;
+    return onEnd;
+};
+const msDuration = () => {
+    const startTime = Date.now();
+    const onEnd = function duration() {
+        return Date.now() - startTime;
+    };
+    onEnd.time = startTime;
+    return onEnd;
+};
+// @ts-ignore
+const duration = process.hrtime ? hrDuration : msDuration;
+exports.default = duration;

package/lib/methods/empty-directory.d.ts

@@ -0,0 +1,2 @@
+import { IIgnoreOptions } from "./walk-directory";
+export default function emptyDirSync(parentFolder: string, options: IIgnoreOptions): void;

package/lib/methods/empty-directory.js

@@ -0,0 +1,47 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fse = __importStar(require("fs-extra"));
+const duration_1 = __importDefault(require("./duration"));
+const walk_directory_1 = __importDefault(require("./walk-directory"));
+function emptyDirSync(parentFolder, options) {
+    const rmComplete = (0, duration_1.default)();
+    const files = (0, walk_directory_1.default)(parentFolder, options);
+    files
+        .forEach((file) => {
+        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());
+}
+exports.default = emptyDirSync;

package/lib/methods/generate-hash.d.ts

@@ -0,0 +1,15 @@
+import { IIgnoreOptions } from './walk-directory';
+interface HashOptions {
+    ignore: IIgnoreOptions;
+}
+export interface HashResult {
+    hash?: string;
+    children?: HashItem[];
+}
+export interface HashItem {
+    hash: string;
+    path: string;
+    name: string;
+}
+export declare function generateHash(folder: string, opt: HashOptions): string;
+export {};

package/lib/methods/generate-hash.js

@@ -0,0 +1,59 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateHash = void 0;
+const crypto = __importStar(require("crypto"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const walk_directory_1 = __importDefault(require("./walk-directory"));
+const ALGO = 'sha1';
+const ENCODING = 'base64';
+function generateHash(folder, opt) {
+    const files = (0, walk_directory_1.default)(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');
+}
+exports.generateHash = generateHash;

package/lib/methods/get-source-directory.d.ts

@@ -0,0 +1,4 @@
+export declare const sourceRoot: string;
+export declare const distributionRoot: string;
+export declare function getSourceDirectory(type: string, id: string): string;
+export declare function getBuildDirectory(type: string, id: string): string;

package/lib/methods/get-source-directory.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBuildDirectory = exports.getSourceDirectory = exports.distributionRoot = exports.sourceRoot = void 0;
+const path = __importStar(require("path"));
+exports.sourceRoot = path.resolve(process.cwd(), "../src");
+exports.distributionRoot = path.resolve(process.cwd(), "../dist");
+function getSourceDirectory(type, id) {
+    return path.join(exports.sourceRoot, type, id);
+}
+exports.getSourceDirectory = getSourceDirectory;
+function getBuildDirectory(type, id) {
+    return path.join(exports.distributionRoot, type, id);
+}
+exports.getBuildDirectory = getBuildDirectory;

package/lib/methods/walk-directory.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+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 declare const yes: () => boolean;
+export declare const no: () => boolean;
+export default function walkDirectory(directory: string, options: IIgnoreOptions, filepaths?: DirentExtended[]): DirentExtended[];
+export interface DirentExtended extends fs.Dirent {
+    fullpath: () => string;
+}

package/lib/methods/walk-directory.js

@@ -0,0 +1,48 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.no = exports.yes = void 0;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const yes = () => true;
+exports.yes = yes;
+const no = () => false;
+exports.no = no;
+function walkDirectory(directory, options, filepaths = []) {
+    const { excluded = exports.no, included = exports.yes, childrenExcluded = exports.no, childrenIncluded = exports.yes } = options;
+    const files = fs.readdirSync(directory, { withFileTypes: true });
+    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;
+}
+exports.default = walkDirectory;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byaga/cdk-patterns",
-  "version": "0.6.1",
+  "version": "0.8.0",
   "description": "Collection of common patterns used when making AWS CloudFormation templates using CDK",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -15,9 +15,11 @@
   "author": "VeryFineHat",
   "license": "MIT",
   "dependencies": {
+    "@types/fs-extra": "^11.0.2",
     "aws-cdk": "^2.92.0",
     "aws-cdk-lib": "^2.92.0",
-    "constructs": "^10.2.69"
+    "constructs": "^10.2.69",
+    "fs-extra": "^11.1.1"
   },
   "devDependencies": {
     "@types/node": "^20.5.0",

package/src/ApiCertificate.ts

@@ -1,31 +1,31 @@
 import {Certificate, CertificateValidation} from "aws-cdk-lib/aws-certificatemanager";
 import {HostedZone, IHostedZone} from "aws-cdk-lib/aws-route53";
-import {CfnOutput} from "aws-cdk-lib";
-import IDeployStack from "./IDeployStack";
+import {Output} from "./Output";
+import DeployStack from "./DeployStack";
 import IDomainConfig from "./IDomainConfig";
 
 export class ApiCertificate extends Certificate {
     hostedZone: IHostedZone
     domain: string
 
-    constructor(stack: IDeployStack, id: string, domain: IDomainConfig) {
+    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 CfnOutput(this, stack.genId(id, "certificate-output"), {
-            value: this.certificateArn ,
-            exportName: stack.genName(id)})
+        new Output(stack, id, this.certificateArn)
         this.hostedZone = hostedZone
     }
 }