aws-cdk 0.0.0

package/lib/toolkit/error.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Represents a general toolkit error in the AWS CDK Toolkit.
+ */
+export declare class ToolkitError extends Error {
+    /**
+     * Determines if a given error is an instance of ToolkitError.
+     */
+    static isToolkitError(x: any): x is ToolkitError;
+    /**
+     * Determines if a given error is an instance of AuthenticationError.
+     */
+    static isAuthenticationError(x: any): x is AuthenticationError;
+    /**
+     * Determines if a given error is an instance of AssemblyError.
+     */
+    static isAssemblyError(x: any): x is AssemblyError;
+    /**
+     * Determines if a given error is an instance of AssemblyError.
+     */
+    static isContextProviderError(x: any): x is ContextProviderError;
+    /**
+     * The type of the error, defaults to "toolkit".
+     */
+    readonly type: string;
+    constructor(message: string, type?: string);
+}
+/**
+ * Represents an authentication-specific error in the AWS CDK Toolkit.
+ */
+export declare class AuthenticationError extends ToolkitError {
+    constructor(message: string);
+}
+/**
+ * Represents an authentication-specific error in the AWS CDK Toolkit.
+ */
+export declare class AssemblyError extends ToolkitError {
+    constructor(message: string);
+}
+/**
+ * Represents an error originating from a Context Provider
+ */
+export declare class ContextProviderError extends ToolkitError {
+    constructor(message: string);
+}

package/lib/toolkit/error.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextProviderError = exports.AssemblyError = exports.AuthenticationError = exports.ToolkitError = void 0;
+const TOOLKIT_ERROR_SYMBOL = Symbol.for('@aws-cdk/toolkit.ToolkitError');
+const AUTHENTICATION_ERROR_SYMBOL = Symbol.for('@aws-cdk/toolkit.AuthenticationError');
+const ASSEMBLY_ERROR_SYMBOL = Symbol.for('@aws-cdk/toolkit.AssemblyError');
+const CONTEXT_PROVIDER_ERROR_SYMBOL = Symbol.for('@aws-cdk/toolkit.ContextProviderError');
+/**
+ * Represents a general toolkit error in the AWS CDK Toolkit.
+ */
+class ToolkitError extends Error {
+    /**
+     * Determines if a given error is an instance of ToolkitError.
+     */
+    static isToolkitError(x) {
+        return x !== null && typeof (x) === 'object' && TOOLKIT_ERROR_SYMBOL in x;
+    }
+    /**
+     * Determines if a given error is an instance of AuthenticationError.
+     */
+    static isAuthenticationError(x) {
+        return this.isToolkitError(x) && AUTHENTICATION_ERROR_SYMBOL in x;
+    }
+    /**
+     * Determines if a given error is an instance of AssemblyError.
+     */
+    static isAssemblyError(x) {
+        return this.isToolkitError(x) && ASSEMBLY_ERROR_SYMBOL in x;
+    }
+    /**
+     * Determines if a given error is an instance of AssemblyError.
+     */
+    static isContextProviderError(x) {
+        return this.isToolkitError(x) && CONTEXT_PROVIDER_ERROR_SYMBOL in x;
+    }
+    constructor(message, type = 'toolkit') {
+        super(message);
+        Object.setPrototypeOf(this, ToolkitError.prototype);
+        Object.defineProperty(this, TOOLKIT_ERROR_SYMBOL, { value: true });
+        this.name = new.target.name;
+        this.type = type;
+    }
+}
+exports.ToolkitError = ToolkitError;
+/**
+ * Represents an authentication-specific error in the AWS CDK Toolkit.
+ */
+class AuthenticationError extends ToolkitError {
+    constructor(message) {
+        super(message, 'authentication');
+        Object.setPrototypeOf(this, AuthenticationError.prototype);
+        Object.defineProperty(this, AUTHENTICATION_ERROR_SYMBOL, { value: true });
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+/**
+ * Represents an authentication-specific error in the AWS CDK Toolkit.
+ */
+class AssemblyError extends ToolkitError {
+    constructor(message) {
+        super(message, 'assembly');
+        Object.setPrototypeOf(this, AssemblyError.prototype);
+        Object.defineProperty(this, ASSEMBLY_ERROR_SYMBOL, { value: true });
+    }
+}
+exports.AssemblyError = AssemblyError;
+/**
+ * Represents an error originating from a Context Provider
+ */
+class ContextProviderError extends ToolkitError {
+    constructor(message) {
+        super(message, 'context-provider');
+        Object.setPrototypeOf(this, ContextProviderError.prototype);
+        Object.defineProperty(this, CONTEXT_PROVIDER_ERROR_SYMBOL, { value: true });
+    }
+}
+exports.ContextProviderError = ContextProviderError;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/tree.d.ts

@@ -0,0 +1,31 @@
+import { CloudAssembly } from '@aws-cdk/cx-api';
+/**
+ * Source information on a construct (class fqn and version)
+ */
+export interface ConstructInfo {
+    readonly fqn: string;
+    readonly version: string;
+}
+/**
+ * A node in the construct tree.
+ */
+export interface ConstructTreeNode {
+    readonly id: string;
+    readonly path: string;
+    readonly children?: {
+        [key: string]: ConstructTreeNode;
+    };
+    readonly attributes?: {
+        [key: string]: any;
+    };
+    /**
+     * Information on the construct class that led to this node, if available
+     */
+    readonly constructInfo?: ConstructInfo;
+}
+/**
+ * Whether the provided predicate is true for at least one element in the construct (sub-)tree.
+ */
+export declare function some(node: ConstructTreeNode, predicate: (n: ConstructTreeNode) => boolean): boolean;
+export declare function loadTree(assembly: CloudAssembly): any;
+export declare function loadTreeFromDir(outdir: string): any;

package/lib/tree.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.some = some;
+exports.loadTree = loadTree;
+exports.loadTreeFromDir = loadTreeFromDir;
+const path = require("path");
+const fs = require("fs-extra");
+const logging_1 = require("./logging");
+/**
+ * Whether the provided predicate is true for at least one element in the construct (sub-)tree.
+ */
+function some(node, predicate) {
+    return node != null && (predicate(node) || findInChildren());
+    function findInChildren() {
+        var _a;
+        return Object.values((_a = node.children) !== null && _a !== void 0 ? _a : {}).some(child => some(child, predicate));
+    }
+}
+function loadTree(assembly) {
+    var _a;
+    try {
+        const outdir = assembly.directory;
+        const fileName = (_a = assembly.tree()) === null || _a === void 0 ? void 0 : _a.file;
+        return fileName ? fs.readJSONSync(path.join(outdir, fileName)).tree : {};
+    }
+    catch (e) {
+        (0, logging_1.trace)(`Failed to get tree.json file: ${e}. Proceeding with empty tree.`);
+        return {};
+    }
+}
+function loadTreeFromDir(outdir) {
+    try {
+        return fs.readJSONSync(path.join(outdir, 'tree.json')).tree;
+    }
+    catch (e) {
+        (0, logging_1.trace)(`Failed to get tree.json file: ${e}. Proceeding with empty tree.`);
+        return {};
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/util/archive.d.ts

@@ -0,0 +1 @@
+export declare function zipDirectory(directory: string, outputFile: string): Promise<void>;

package/lib/util/archive.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zipDirectory = zipDirectory;
+const console_1 = require("console");
+const fs_1 = require("fs");
+const path = require("path");
+const glob = require("glob");
+const error_1 = require("./error");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const archiver = require('archiver');
+// Adapted from cdk-assets
+async function zipDirectory(directory, outputFile) {
+    // We write to a temporary file and rename at the last moment. This is so that if we are
+    // interrupted during this process, we don't leave a half-finished file in the target location.
+    const temporaryOutputFile = `${outputFile}.${randomString()}._tmp`;
+    await writeZipFile(directory, temporaryOutputFile);
+    await moveIntoPlace(temporaryOutputFile, outputFile);
+}
+function writeZipFile(directory, outputFile) {
+    return new Promise(async (ok, fail) => {
+        // The below options are needed to support following symlinks when building zip files:
+        // - nodir: This will prevent symlinks themselves from being copied into the zip.
+        // - follow: This will follow symlinks and copy the files within.
+        const globOptions = {
+            dot: true,
+            nodir: true,
+            follow: true,
+            cwd: directory,
+        };
+        const files = glob.sync('**', globOptions); // The output here is already sorted
+        const output = (0, fs_1.createWriteStream)(outputFile);
+        const archive = archiver('zip');
+        archive.on('warning', fail);
+        archive.on('error', fail);
+        // archive has been finalized and the output file descriptor has closed, resolve promise
+        // this has to be done before calling `finalize` since the events may fire immediately after.
+        // see https://www.npmjs.com/package/archiver
+        output.once('close', ok);
+        archive.pipe(output);
+        // Append files serially to ensure file order
+        for (const file of files) {
+            const fullPath = path.resolve(directory, file);
+            // Exactly 2 promises
+            // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism
+            const [data, stat] = await Promise.all([fs_1.promises.readFile(fullPath), fs_1.promises.stat(fullPath)]);
+            archive.append(data, {
+                name: file,
+                mode: stat.mode,
+            });
+        }
+        await archive.finalize();
+    });
+}
+/**
+ * Rename the file to the target location, taking into account:
+ *
+ * - That we may see EPERM on Windows while an Antivirus scanner still has the
+ *   file open, so retry a couple of times.
+ * - This same function may be called in parallel and be interrupted at any point.
+ */
+async function moveIntoPlace(source, target) {
+    let delay = 100;
+    let attempts = 5;
+    while (true) {
+        try {
+            // 'rename' is guaranteed to overwrite an existing target, as long as it is a file (not a directory)
+            await fs_1.promises.rename(source, target);
+            return;
+        }
+        catch (e) {
+            if (e.code !== 'EPERM' || attempts-- <= 0) {
+                throw e;
+            }
+            (0, console_1.error)((0, error_1.formatErrorMessage)(e));
+            await sleep(Math.floor(Math.random() * delay));
+            delay *= 2;
+        }
+    }
+}
+function sleep(ms) {
+    return new Promise(ok => setTimeout(ok, ms));
+}
+function randomString() {
+    return Math.random().toString(36).replace(/[^a-z0-9]+/g, '');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/util/arrays.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Map a function over an array and concatenate the results
+ */
+export declare function flatMap<T, U>(xs: T[], fn: ((x: T, i: number) => U[])): U[];
+/**
+ * Flatten a list of lists into a list of elements
+ */
+export declare function flatten<T>(xs: T[][]): T[];
+/**
+ * Partition a collection by removing and returning all elements that match a predicate
+ *
+ * Note: the input collection is modified in-place!
+ */
+export declare function partition<T>(collection: T[], pred: (x: T) => boolean): T[];

package/lib/util/arrays.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flatMap = flatMap;
+exports.flatten = flatten;
+exports.partition = partition;
+/**
+ * Map a function over an array and concatenate the results
+ */
+function flatMap(xs, fn) {
+    return flatten(xs.map(fn));
+}
+/**
+ * Flatten a list of lists into a list of elements
+ */
+function flatten(xs) {
+    return Array.prototype.concat.apply([], xs);
+}
+/**
+ * Partition a collection by removing and returning all elements that match a predicate
+ *
+ * Note: the input collection is modified in-place!
+ */
+function partition(collection, pred) {
+    const ret = [];
+    let i = 0;
+    while (i < collection.length) {
+        if (pred(collection[i])) {
+            ret.push(collection.splice(i, 1)[0]);
+        }
+        else {
+            i++;
+        }
+    }
+    return ret;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/util/bool.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Converts a boolean into a number.
+ *
+ * @param bool input boolean
+ * @returns 1 if bool is true, and 0 if false
+ */
+export declare function numberFromBool(bool: boolean): number;

package/lib/util/bool.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberFromBool = numberFromBool;
+/**
+ * Converts a boolean into a number.
+ *
+ * @param bool input boolean
+ * @returns 1 if bool is true, and 0 if false
+ */
+function numberFromBool(bool) {
+    return +bool;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYm9vbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImJvb2wudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFNQSx3Q0FFQztBQVJEOzs7OztHQUtHO0FBQ0gsU0FBZ0IsY0FBYyxDQUFDLElBQWE7SUFDMUMsT0FBTyxDQUFDLElBQUksQ0FBQztBQUNmLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENvbnZlcnRzIGEgYm9vbGVhbiBpbnRvIGEgbnVtYmVyLlxuICpcbiAqIEBwYXJhbSBib29sIGlucHV0IGJvb2xlYW5cbiAqIEByZXR1cm5zIDEgaWYgYm9vbCBpcyB0cnVlLCBhbmQgMCBpZiBmYWxzZVxuICovXG5leHBvcnQgZnVuY3Rpb24gbnVtYmVyRnJvbUJvb2woYm9vbDogYm9vbGVhbik6IG51bWJlciB7XG4gIHJldHVybiArYm9vbDtcbn1cbiJdfQ==

package/lib/util/bytes.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Format bytes as a human readable string
+ *
+ * @param bytes Number of bytes to format
+ * @param decimals Number of decimal places to show (default 2)
+ * @returns Formatted string with appropriate unit suffix
+ */
+export declare function formatBytes(bytes: number, decimals?: number): string;

package/lib/util/bytes.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatBytes = formatBytes;
+/**
+ * Format bytes as a human readable string
+ *
+ * @param bytes Number of bytes to format
+ * @param decimals Number of decimal places to show (default 2)
+ * @returns Formatted string with appropriate unit suffix
+ */
+function formatBytes(bytes, decimals = 2) {
+    decimals = decimals < 0 ? 0 : decimals;
+    if (bytes === 0) {
+        return '0 Bytes';
+    }
+    const k = 1024;
+    const sizes = ['Bytes', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(decimals))} ${sizes[i]}`;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnl0ZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJieXRlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQU9BLGtDQWFDO0FBcEJEOzs7Ozs7R0FNRztBQUNILFNBQWdCLFdBQVcsQ0FBQyxLQUFhLEVBQUUsV0FBbUIsQ0FBQztJQUM3RCxRQUFRLEdBQUcsUUFBUSxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUM7SUFFdkMsSUFBSSxLQUFLLEtBQUssQ0FBQyxFQUFFLENBQUM7UUFDaEIsT0FBTyxTQUFTLENBQUM7SUFDbkIsQ0FBQztJQUVELE1BQU0sQ0FBQyxHQUFHLElBQUksQ0FBQztJQUNmLE1BQU0sS0FBSyxHQUFHLENBQUMsT0FBTyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLENBQUMsQ0FBQztJQUVoRixNQUFNLENBQUMsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBRXBELE9BQU8sR0FBRyxVQUFVLENBQUMsQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLENBQUMsSUFBSSxLQUFLLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztBQUNqRixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBGb3JtYXQgYnl0ZXMgYXMgYSBodW1hbiByZWFkYWJsZSBzdHJpbmdcbiAqXG4gKiBAcGFyYW0gYnl0ZXMgTnVtYmVyIG9mIGJ5dGVzIHRvIGZvcm1hdFxuICogQHBhcmFtIGRlY2ltYWxzIE51bWJlciBvZiBkZWNpbWFsIHBsYWNlcyB0byBzaG93IChkZWZhdWx0IDIpXG4gKiBAcmV0dXJucyBGb3JtYXR0ZWQgc3RyaW5nIHdpdGggYXBwcm9wcmlhdGUgdW5pdCBzdWZmaXhcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGZvcm1hdEJ5dGVzKGJ5dGVzOiBudW1iZXIsIGRlY2ltYWxzOiBudW1iZXIgPSAyKTogc3RyaW5nIHtcbiAgZGVjaW1hbHMgPSBkZWNpbWFscyA8IDAgPyAwIDogZGVjaW1hbHM7XG5cbiAgaWYgKGJ5dGVzID09PSAwKSB7XG4gICAgcmV0dXJuICcwIEJ5dGVzJztcbiAgfVxuXG4gIGNvbnN0IGsgPSAxMDI0O1xuICBjb25zdCBzaXplcyA9IFsnQnl0ZXMnLCAnS2lCJywgJ01pQicsICdHaUInLCAnVGlCJywgJ1BpQicsICdFaUInLCAnWmlCJywgJ1lpQiddO1xuXG4gIGNvbnN0IGkgPSBNYXRoLmZsb29yKE1hdGgubG9nKGJ5dGVzKSAvIE1hdGgubG9nKGspKTtcblxuICByZXR1cm4gYCR7cGFyc2VGbG9hdCgoYnl0ZXMgLyBNYXRoLnBvdyhrLCBpKSkudG9GaXhlZChkZWNpbWFscykpfSAke3NpemVzW2ldfWA7XG59XG4iXX0=

package/lib/util/content-hash.d.ts

@@ -0,0 +1,5 @@
+export declare function contentHash(data: string | Buffer | DataView): string;
+/**
+ * A stably sorted hash of an arbitrary JS object
+ */
+export declare function contentHashAny(value: unknown): string;

package/lib/util/content-hash.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contentHash = contentHash;
+exports.contentHashAny = contentHashAny;
+const crypto = require("crypto");
+function contentHash(data) {
+    return crypto.createHash('sha256').update(data).digest('hex');
+}
+/**
+ * A stably sorted hash of an arbitrary JS object
+ */
+function contentHashAny(value) {
+    const ret = crypto.createHash('sha256');
+    recurse(value);
+    return ret.digest('hex');
+    function recurse(x) {
+        if (typeof x === 'string') {
+            ret.update(x);
+            return;
+        }
+        if (Array.isArray(x)) {
+            ret.update('[');
+            for (const e of x) {
+                recurse(e);
+                ret.update('||');
+            }
+            ret.update(']');
+            return;
+        }
+        if (x && typeof x === 'object') {
+            ret.update('{');
+            for (const key of Object.keys(x).sort()) {
+                ret.update(key);
+                ret.update(':');
+                recurse(x[key]);
+            }
+            ret.update('}');
+            return;
+        }
+        ret.update(`${x}${typeof x}`); // typeof to make sure hash('123') !== hash(123)
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/util/directories.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Return a location that will be used as the CDK home directory.
+ * Currently the only thing that is placed here is the cache.
+ *
+ * First try to use the users home directory (i.e. /home/someuser/),
+ * but if that directory does not exist for some reason create a tmp directory.
+ *
+ * Typically it wouldn't make sense to create a one time use tmp directory for
+ * the purpose of creating a cache, but since this only applies to users that do
+ * not have a home directory (some CI systems?) this should be fine.
+ */
+export declare function cdkHomeDir(): string;
+export declare function cdkCacheDir(): string;
+/**
+ * From the current file, find the directory that contains the CLI's package.json
+ *
+ * Can't use `__dirname` in production code, as the CLI will get bundled as it's
+ * released and `__dirname` will refer to a different location in the `.ts` form
+ * as it will in the final executing form.
+ */
+export declare function rootDir(): string;
+export declare function rootDir(fail: true): string;
+export declare function rootDir(fail: false): string | undefined;

package/lib/util/directories.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cdkHomeDir = cdkHomeDir;
+exports.cdkCacheDir = cdkCacheDir;
+exports.rootDir = rootDir;
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const error_1 = require("../toolkit/error");
+/**
+ * Return a location that will be used as the CDK home directory.
+ * Currently the only thing that is placed here is the cache.
+ *
+ * First try to use the users home directory (i.e. /home/someuser/),
+ * but if that directory does not exist for some reason create a tmp directory.
+ *
+ * Typically it wouldn't make sense to create a one time use tmp directory for
+ * the purpose of creating a cache, but since this only applies to users that do
+ * not have a home directory (some CI systems?) this should be fine.
+ */
+function cdkHomeDir() {
+    const tmpDir = fs.realpathSync(os.tmpdir());
+    let home;
+    try {
+        let userInfoHome = os.userInfo().homedir;
+        // Node returns this if the user doesn't have a home directory
+        /* istanbul ignore if: will not happen in normal setups */
+        if (userInfoHome == '/var/empty') {
+            userInfoHome = undefined;
+        }
+        home = path.join((userInfoHome !== null && userInfoHome !== void 0 ? userInfoHome : os.homedir()).trim(), '.cdk');
+    }
+    catch { }
+    return process.env.CDK_HOME
+        ? path.resolve(process.env.CDK_HOME)
+        : home || fs.mkdtempSync(path.join(tmpDir, '.cdk')).trim();
+}
+function cdkCacheDir() {
+    return path.join(cdkHomeDir(), 'cache');
+}
+function rootDir(fail) {
+    function _rootDir(dirname) {
+        const manifestPath = path.join(dirname, 'package.json');
+        if (fs.existsSync(manifestPath)) {
+            return dirname;
+        }
+        if (path.dirname(dirname) === dirname) {
+            if (fail !== null && fail !== void 0 ? fail : true) {
+                throw new error_1.ToolkitError('Unable to find package manifest');
+            }
+            return undefined;
+        }
+        return _rootDir(path.dirname(dirname));
+    }
+    return _rootDir(__dirname);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/util/error.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Takes in an error and returns a correctly formatted string of its error message.
+ * If it is an AggregateError, it will return a string with all the inner errors
+ * formatted and separated by a newline.
+ *
+ * @param error The error to format
+ * @returns A string with the error message(s) of the error
+ */
+export declare function formatErrorMessage(error: any): string;

package/lib/util/error.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatErrorMessage = formatErrorMessage;
+/**
+ * Takes in an error and returns a correctly formatted string of its error message.
+ * If it is an AggregateError, it will return a string with all the inner errors
+ * formatted and separated by a newline.
+ *
+ * @param error The error to format
+ * @returns A string with the error message(s) of the error
+ */
+function formatErrorMessage(error) {
+    if (error && Array.isArray(error.errors)) {
+        const innerMessages = error.errors
+            .map((innerError) => ((innerError === null || innerError === void 0 ? void 0 : innerError.message) || (innerError === null || innerError === void 0 ? void 0 : innerError.toString())))
+            .join('\n');
+        return `AggregateError: ${innerMessages}`;
+    }
+    // Fallback for regular Error or other types
+    return (error === null || error === void 0 ? void 0 : error.message) || (error === null || error === void 0 ? void 0 : error.toString()) || 'Unknown error';
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJlcnJvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQVFBLGdEQVVDO0FBbEJEOzs7Ozs7O0dBT0c7QUFDSCxTQUFnQixrQkFBa0IsQ0FBQyxLQUFVO0lBQzNDLElBQUksS0FBSyxJQUFJLEtBQUssQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUM7UUFDekMsTUFBTSxhQUFhLEdBQUcsS0FBSyxDQUFDLE1BQU07YUFDL0IsR0FBRyxDQUFDLENBQUMsVUFBaUQsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFBLFVBQVUsYUFBVixVQUFVLHVCQUFWLFVBQVUsQ0FBRSxPQUFPLE1BQUksVUFBVSxhQUFWLFVBQVUsdUJBQVYsVUFBVSxDQUFFLFFBQVEsRUFBRSxDQUFBLENBQUMsQ0FBQzthQUMzRyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDZCxPQUFPLG1CQUFtQixhQUFhLEVBQUUsQ0FBQztJQUM1QyxDQUFDO0lBRUQsNENBQTRDO0lBQzVDLE9BQU8sQ0FBQSxLQUFLLGFBQUwsS0FBSyx1QkFBTCxLQUFLLENBQUUsT0FBTyxNQUFJLEtBQUssYUFBTCxLQUFLLHVCQUFMLEtBQUssQ0FBRSxRQUFRLEVBQUUsQ0FBQSxJQUFJLGVBQWUsQ0FBQztBQUNoRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBUYWtlcyBpbiBhbiBlcnJvciBhbmQgcmV0dXJucyBhIGNvcnJlY3RseSBmb3JtYXR0ZWQgc3RyaW5nIG9mIGl0cyBlcnJvciBtZXNzYWdlLlxuICogSWYgaXQgaXMgYW4gQWdncmVnYXRlRXJyb3IsIGl0IHdpbGwgcmV0dXJuIGEgc3RyaW5nIHdpdGggYWxsIHRoZSBpbm5lciBlcnJvcnNcbiAqIGZvcm1hdHRlZCBhbmQgc2VwYXJhdGVkIGJ5IGEgbmV3bGluZS5cbiAqXG4gKiBAcGFyYW0gZXJyb3IgVGhlIGVycm9yIHRvIGZvcm1hdFxuICogQHJldHVybnMgQSBzdHJpbmcgd2l0aCB0aGUgZXJyb3IgbWVzc2FnZShzKSBvZiB0aGUgZXJyb3JcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGZvcm1hdEVycm9yTWVzc2FnZShlcnJvcjogYW55KTogc3RyaW5nIHtcbiAgaWYgKGVycm9yICYmIEFycmF5LmlzQXJyYXkoZXJyb3IuZXJyb3JzKSkge1xuICAgIGNvbnN0IGlubmVyTWVzc2FnZXMgPSBlcnJvci5lcnJvcnNcbiAgICAgIC5tYXAoKGlubmVyRXJyb3I6IHsgbWVzc2FnZTogYW55OyB0b1N0cmluZzogKCkgPT4gYW55IH0pID0+IChpbm5lckVycm9yPy5tZXNzYWdlIHx8IGlubmVyRXJyb3I/LnRvU3RyaW5nKCkpKVxuICAgICAgLmpvaW4oJ1xcbicpO1xuICAgIHJldHVybiBgQWdncmVnYXRlRXJyb3I6ICR7aW5uZXJNZXNzYWdlc31gO1xuICB9XG5cbiAgLy8gRmFsbGJhY2sgZm9yIHJlZ3VsYXIgRXJyb3Igb3Igb3RoZXIgdHlwZXNcbiAgcmV0dXJuIGVycm9yPy5tZXNzYWdlIHx8IGVycm9yPy50b1N0cmluZygpIHx8ICdVbmtub3duIGVycm9yJztcbn1cbiJdfQ==

package/lib/util/index.d.ts

@@ -0,0 +1,5 @@
+export * from './arrays';
+export * from './bool';
+export * from './objects';
+export * from './types';
+export * from './tables';