aws-cdk 0.0.0

package/lib/cli/platform-warnings.d.ts

@@ -0,0 +1,2 @@
+export declare function checkForPlatformWarnings(): Promise<void>;
+export declare function isVersionBetween(version: string, lower: string, upper: string): boolean;

package/lib/cli/platform-warnings.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkForPlatformWarnings = checkForPlatformWarnings;
+exports.isVersionBetween = isVersionBetween;
+const os = require("os");
+const fs = require("fs-extra");
+const logging = require("../logging");
+async function checkForPlatformWarnings() {
+    if (await hasDockerCopyBug()) {
+        logging.warning('`cdk synth` may hang in Docker on Linux 5.6-5.10. See https://github.com/aws/aws-cdk/issues/21379 for workarounds.');
+    }
+}
+async function hasDockerCopyBug() {
+    return await runningInDocker() && os.platform() === 'linux' && isVersionBetween(os.release(), '5.6', '5.10');
+}
+async function runningInDocker() {
+    return fs.pathExists('/.dockerenv');
+}
+function isVersionBetween(version, lower, upper) {
+    const ver = splitVersion(version);
+    const lo = splitVersion(lower);
+    const up = splitVersion(upper);
+    while (lo.length < ver.length) {
+        lo.push(0);
+    }
+    while (up.length < ver.length) {
+        up.push(9999999);
+    }
+    let n = ver.length;
+    for (let i = 0; i < n; i++) {
+        if (lo[i] < ver[i] && ver[i] < up[i]) {
+            return true;
+        }
+        if (lo[i] > ver[i] || ver[i] > up[i]) {
+            return false;
+        }
+    }
+    return false;
+}
+function splitVersion(version) {
+    return `${version}`.split('.')
+        .map(x => parseInt(x, 10))
+        .map(x => isNaN(x) ? 0 : x);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGxhdGZvcm0td2FybmluZ3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJwbGF0Zm9ybS13YXJuaW5ncy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUlBLDREQUlDO0FBVUQsNENBZ0JDO0FBbENELHlCQUF5QjtBQUN6QiwrQkFBK0I7QUFDL0Isc0NBQXNDO0FBRS9CLEtBQUssVUFBVSx3QkFBd0I7SUFDNUMsSUFBSSxNQUFNLGdCQUFnQixFQUFFLEVBQUUsQ0FBQztRQUM3QixPQUFPLENBQUMsT0FBTyxDQUFDLG9IQUFvSCxDQUFDLENBQUM7SUFDeEksQ0FBQztBQUNILENBQUM7QUFFRCxLQUFLLFVBQVUsZ0JBQWdCO0lBQzdCLE9BQU8sTUFBTSxlQUFlLEVBQUUsSUFBSSxFQUFFLENBQUMsUUFBUSxFQUFFLEtBQUssT0FBTyxJQUFJLGdCQUFnQixDQUFDLEVBQUUsQ0FBQyxPQUFPLEVBQUUsRUFBRSxLQUFLLEVBQUUsTUFBTSxDQUFDLENBQUM7QUFDL0csQ0FBQztBQUVELEtBQUssVUFBVSxlQUFlO0lBQzVCLE9BQU8sRUFBRSxDQUFDLFVBQVUsQ0FBQyxhQUFhLENBQUMsQ0FBQztBQUN0QyxDQUFDO0FBRUQsU0FBZ0IsZ0JBQWdCLENBQUMsT0FBZSxFQUFFLEtBQWEsRUFBRSxLQUFhO0lBQzVFLE1BQU0sR0FBRyxHQUFHLFlBQVksQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUNsQyxNQUFNLEVBQUUsR0FBRyxZQUFZLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDL0IsTUFBTSxFQUFFLEdBQUcsWUFBWSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBRS9CLE9BQU8sRUFBRSxDQUFDLE1BQU0sR0FBRyxHQUFHLENBQUMsTUFBTSxFQUFFLENBQUM7UUFBQyxFQUFFLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQUMsQ0FBQztJQUM5QyxPQUFPLEVBQUUsQ0FBQyxNQUFNLEdBQUcsR0FBRyxDQUFDLE1BQU0sRUFBRSxDQUFDO1FBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUFDLENBQUM7SUFFcEQsSUFBSSxDQUFDLEdBQUcsR0FBRyxDQUFDLE1BQU0sQ0FBQztJQUNuQixLQUFLLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsRUFBRSxFQUFFLENBQUM7UUFDM0IsSUFBSSxFQUFFLENBQUMsQ0FBQyxDQUFDLEdBQUcsR0FBRyxDQUFDLENBQUMsQ0FBQyxJQUFJLEdBQUcsQ0FBQyxDQUFDLENBQUMsR0FBRyxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztZQUFDLE9BQU8sSUFBSSxDQUFDO1FBQUMsQ0FBQztRQUN0RCxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUMsR0FBRyxHQUFHLENBQUMsQ0FBQyxDQUFDLElBQUksR0FBRyxDQUFDLENBQUMsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDO1lBQUMsT0FBTyxLQUFLLENBQUM7UUFBQyxDQUFDO0lBQ3pELENBQUM7SUFFRCxPQUFPLEtBQUssQ0FBQztBQUVmLENBQUM7QUFFRCxTQUFTLFlBQVksQ0FBQyxPQUFlO0lBQ25DLE9BQU8sR0FBRyxPQUFPLEVBQUUsQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDO1NBQzNCLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLFFBQVEsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUM7U0FDekIsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0FBQ2hDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBvcyBmcm9tICdvcyc7XG5pbXBvcnQgKiBhcyBmcyBmcm9tICdmcy1leHRyYSc7XG5pbXBvcnQgKiBhcyBsb2dnaW5nIGZyb20gJy4uL2xvZ2dpbmcnO1xuXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gY2hlY2tGb3JQbGF0Zm9ybVdhcm5pbmdzKCkge1xuICBpZiAoYXdhaXQgaGFzRG9ja2VyQ29weUJ1ZygpKSB7XG4gICAgbG9nZ2luZy53YXJuaW5nKCdgY2RrIHN5bnRoYCBtYXkgaGFuZyBpbiBEb2NrZXIgb24gTGludXggNS42LTUuMTAuIFNlZSBodHRwczovL2dpdGh1Yi5jb20vYXdzL2F3cy1jZGsvaXNzdWVzLzIxMzc5IGZvciB3b3JrYXJvdW5kcy4nKTtcbiAgfVxufVxuXG5hc3luYyBmdW5jdGlvbiBoYXNEb2NrZXJDb3B5QnVnKCkge1xuICByZXR1cm4gYXdhaXQgcnVubmluZ0luRG9ja2VyKCkgJiYgb3MucGxhdGZvcm0oKSA9PT0gJ2xpbnV4JyAmJiBpc1ZlcnNpb25CZXR3ZWVuKG9zLnJlbGVhc2UoKSwgJzUuNicsICc1LjEwJyk7XG59XG5cbmFzeW5jIGZ1bmN0aW9uIHJ1bm5pbmdJbkRvY2tlcigpIHtcbiAgcmV0dXJuIGZzLnBhdGhFeGlzdHMoJy8uZG9ja2VyZW52Jyk7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBpc1ZlcnNpb25CZXR3ZWVuKHZlcnNpb246IHN0cmluZywgbG93ZXI6IHN0cmluZywgdXBwZXI6IHN0cmluZykge1xuICBjb25zdCB2ZXIgPSBzcGxpdFZlcnNpb24odmVyc2lvbik7XG4gIGNvbnN0IGxvID0gc3BsaXRWZXJzaW9uKGxvd2VyKTtcbiAgY29uc3QgdXAgPSBzcGxpdFZlcnNpb24odXBwZXIpO1xuXG4gIHdoaWxlIChsby5sZW5ndGggPCB2ZXIubGVuZ3RoKSB7IGxvLnB1c2goMCk7IH1cbiAgd2hpbGUgKHVwLmxlbmd0aCA8IHZlci5sZW5ndGgpIHsgdXAucHVzaCg5OTk5OTk5KTsgfVxuXG4gIGxldCBuID0gdmVyLmxlbmd0aDtcbiAgZm9yIChsZXQgaSA9IDA7IGkgPCBuOyBpKyspIHtcbiAgICBpZiAobG9baV0gPCB2ZXJbaV0gJiYgdmVyW2ldIDwgdXBbaV0pIHsgcmV0dXJuIHRydWU7IH1cbiAgICBpZiAobG9baV0gPiB2ZXJbaV0gfHwgdmVyW2ldID4gdXBbaV0pIHsgcmV0dXJuIGZhbHNlOyB9XG4gIH1cblxuICByZXR1cm4gZmFsc2U7XG5cbn1cblxuZnVuY3Rpb24gc3BsaXRWZXJzaW9uKHZlcnNpb246IHN0cmluZyk6IG51bWJlcltdIHtcbiAgcmV0dXJuIGAke3ZlcnNpb259YC5zcGxpdCgnLicpXG4gICAgLm1hcCh4ID0+IHBhcnNlSW50KHgsIDEwKSlcbiAgICAubWFwKHggPT4gaXNOYU4oeCkgPyAwIDogeCk7XG59XG4iXX0=

package/lib/cli/user-configuration.d.ts

@@ -0,0 +1,90 @@
+import { Context } from '../api/context';
+import { Settings } from '../api/settings';
+export declare const PROJECT_CONFIG = "cdk.json";
+export { PROJECT_CONTEXT } from '../api/context';
+export declare const USER_DEFAULTS = "~/.cdk.json";
+export declare enum Command {
+    LS = "ls",
+    LIST = "list",
+    DIFF = "diff",
+    BOOTSTRAP = "bootstrap",
+    DEPLOY = "deploy",
+    DESTROY = "destroy",
+    SYNTHESIZE = "synthesize",
+    SYNTH = "synth",
+    METADATA = "metadata",
+    INIT = "init",
+    VERSION = "version",
+    WATCH = "watch",
+    GC = "gc",
+    ROLLBACK = "rollback",
+    IMPORT = "import",
+    ACKNOWLEDGE = "acknowledge",
+    ACK = "ack",
+    NOTICES = "notices",
+    MIGRATE = "migrate",
+    CONTEXT = "context",
+    DOCS = "docs",
+    DOC = "doc",
+    DOCTOR = "doctor"
+}
+export type Arguments = {
+    readonly _: [Command, ...string[]];
+    readonly exclusively?: boolean;
+    readonly STACKS?: string[];
+    readonly lookups?: boolean;
+    readonly [name: string]: unknown;
+};
+export interface ConfigurationProps {
+    /**
+     * Configuration passed via command line arguments
+     *
+     * @default - Nothing passed
+     */
+    readonly commandLineArguments?: Arguments;
+    /**
+     * Whether or not to use context from `.cdk.json` in user home directory
+     *
+     * @default true
+     */
+    readonly readUserContext?: boolean;
+}
+/**
+ * All sources of settings combined
+ */
+export declare class Configuration {
+    private readonly props;
+    settings: Settings;
+    context: Context;
+    readonly defaultConfig: Settings;
+    private readonly commandLineArguments;
+    private readonly commandLineContext;
+    private _projectConfig?;
+    private _projectContext?;
+    private loaded;
+    constructor(props?: ConfigurationProps);
+    private get projectConfig();
+    get projectContext(): Settings;
+    /**
+     * Load all config
+     */
+    load(): Promise<this>;
+    /**
+     * Save the project context
+     */
+    saveContext(): Promise<this>;
+}
+/**
+ * Parse CLI arguments into Settings
+ *
+ * CLI arguments in must be accessed in the CLI code via
+ * `configuration.settings.get(['argName'])` instead of via `args.argName`.
+ *
+ * The advantage is that they can be configured via `cdk.json` and
+ * `$HOME/.cdk.json`. Arguments not listed below and accessed via this object
+ * can only be specified on the command line.
+ *
+ * @param argv the received CLI arguments.
+ * @returns a new Settings object.
+ */
+export declare function commandLineArgumentsToSettings(argv: Arguments): Settings;

package/lib/cli/user-configuration.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Configuration = exports.Command = exports.USER_DEFAULTS = exports.PROJECT_CONTEXT = exports.PROJECT_CONFIG = void 0;
+exports.commandLineArgumentsToSettings = commandLineArgumentsToSettings;
+const context_1 = require("../api/context");
+const settings_1 = require("../api/settings");
+const logging_1 = require("../logging");
+const error_1 = require("../toolkit/error");
+exports.PROJECT_CONFIG = 'cdk.json';
+var context_2 = require("../api/context");
+Object.defineProperty(exports, "PROJECT_CONTEXT", { enumerable: true, get: function () { return context_2.PROJECT_CONTEXT; } });
+exports.USER_DEFAULTS = '~/.cdk.json';
+const CONTEXT_KEY = 'context';
+var Command;
+(function (Command) {
+    Command["LS"] = "ls";
+    Command["LIST"] = "list";
+    Command["DIFF"] = "diff";
+    Command["BOOTSTRAP"] = "bootstrap";
+    Command["DEPLOY"] = "deploy";
+    Command["DESTROY"] = "destroy";
+    Command["SYNTHESIZE"] = "synthesize";
+    Command["SYNTH"] = "synth";
+    Command["METADATA"] = "metadata";
+    Command["INIT"] = "init";
+    Command["VERSION"] = "version";
+    Command["WATCH"] = "watch";
+    Command["GC"] = "gc";
+    Command["ROLLBACK"] = "rollback";
+    Command["IMPORT"] = "import";
+    Command["ACKNOWLEDGE"] = "acknowledge";
+    Command["ACK"] = "ack";
+    Command["NOTICES"] = "notices";
+    Command["MIGRATE"] = "migrate";
+    Command["CONTEXT"] = "context";
+    Command["DOCS"] = "docs";
+    Command["DOC"] = "doc";
+    Command["DOCTOR"] = "doctor";
+})(Command || (exports.Command = Command = {}));
+const BUNDLING_COMMANDS = [
+    Command.DEPLOY,
+    Command.DIFF,
+    Command.SYNTH,
+    Command.SYNTHESIZE,
+    Command.WATCH,
+    Command.IMPORT,
+];
+/**
+ * All sources of settings combined
+ */
+class Configuration {
+    constructor(props = {}) {
+        this.props = props;
+        this.settings = new settings_1.Settings();
+        this.context = new context_1.Context();
+        this.defaultConfig = new settings_1.Settings({
+            versionReporting: true,
+            assetMetadata: true,
+            pathMetadata: true,
+            output: 'cdk.out',
+        });
+        this.loaded = false;
+        this.commandLineArguments = props.commandLineArguments
+            ? commandLineArgumentsToSettings(props.commandLineArguments)
+            : new settings_1.Settings();
+        this.commandLineContext = this.commandLineArguments
+            .subSettings([CONTEXT_KEY])
+            .makeReadOnly();
+    }
+    get projectConfig() {
+        if (!this._projectConfig) {
+            throw new error_1.ToolkitError('#load has not been called yet!');
+        }
+        return this._projectConfig;
+    }
+    get projectContext() {
+        if (!this._projectContext) {
+            throw new error_1.ToolkitError('#load has not been called yet!');
+        }
+        return this._projectContext;
+    }
+    /**
+     * Load all config
+     */
+    async load() {
+        var _a;
+        const userConfig = await loadAndLog(exports.USER_DEFAULTS);
+        this._projectConfig = await loadAndLog(exports.PROJECT_CONFIG);
+        this._projectContext = await loadAndLog(context_1.PROJECT_CONTEXT);
+        // @todo cannot currently be disabled by cli users
+        const readUserContext = (_a = this.props.readUserContext) !== null && _a !== void 0 ? _a : true;
+        if (userConfig.get(['build'])) {
+            throw new error_1.ToolkitError('The `build` key cannot be specified in the user config (~/.cdk.json), specify it in the project config (cdk.json) instead');
+        }
+        const contextSources = [
+            { bag: this.commandLineContext },
+            {
+                fileName: exports.PROJECT_CONFIG,
+                bag: this.projectConfig.subSettings([CONTEXT_KEY]).makeReadOnly(),
+            },
+            { fileName: context_1.PROJECT_CONTEXT, bag: this.projectContext },
+        ];
+        if (readUserContext) {
+            contextSources.push({
+                fileName: exports.USER_DEFAULTS,
+                bag: userConfig.subSettings([CONTEXT_KEY]).makeReadOnly(),
+            });
+        }
+        this.context = new context_1.Context(...contextSources);
+        // Build settings from what's left
+        this.settings = this.defaultConfig
+            .merge(userConfig)
+            .merge(this.projectConfig)
+            .merge(this.commandLineArguments)
+            .makeReadOnly();
+        (0, logging_1.debug)('merged settings:', this.settings.all);
+        this.loaded = true;
+        return this;
+    }
+    /**
+     * Save the project context
+     */
+    async saveContext() {
+        if (!this.loaded) {
+            return this;
+        } // Avoid overwriting files with nothing
+        await this.projectContext.save(context_1.PROJECT_CONTEXT);
+        return this;
+    }
+}
+exports.Configuration = Configuration;
+async function loadAndLog(fileName) {
+    const ret = new settings_1.Settings();
+    await ret.load(fileName);
+    if (!ret.empty) {
+        (0, logging_1.debug)(fileName + ':', JSON.stringify(ret.all, undefined, 2));
+    }
+    return ret;
+}
+/**
+ * Parse CLI arguments into Settings
+ *
+ * CLI arguments in must be accessed in the CLI code via
+ * `configuration.settings.get(['argName'])` instead of via `args.argName`.
+ *
+ * The advantage is that they can be configured via `cdk.json` and
+ * `$HOME/.cdk.json`. Arguments not listed below and accessed via this object
+ * can only be specified on the command line.
+ *
+ * @param argv the received CLI arguments.
+ * @returns a new Settings object.
+ */
+function commandLineArgumentsToSettings(argv) {
+    var _a;
+    const context = parseStringContextListToObject(argv);
+    const tags = parseStringTagsListToObject(expectStringList(argv.tags));
+    // Determine bundling stacks
+    let bundlingStacks;
+    if (BUNDLING_COMMANDS.includes(argv._[0])) {
+        // If we deploy, diff, synth or watch a list of stacks exclusively we skip
+        // bundling for all other stacks.
+        bundlingStacks = argv.exclusively ? (_a = argv.STACKS) !== null && _a !== void 0 ? _a : ['**'] : ['**'];
+    }
+    else {
+        // Skip bundling for all stacks
+        bundlingStacks = [];
+    }
+    return new settings_1.Settings({
+        app: argv.app,
+        browser: argv.browser,
+        build: argv.build,
+        caBundlePath: argv.caBundlePath,
+        context,
+        debug: argv.debug,
+        tags,
+        language: argv.language,
+        pathMetadata: argv.pathMetadata,
+        assetMetadata: argv.assetMetadata,
+        profile: argv.profile,
+        plugin: argv.plugin,
+        requireApproval: argv.requireApproval,
+        toolkitStackName: argv.toolkitStackName,
+        toolkitBucket: {
+            bucketName: argv.bootstrapBucketName,
+            kmsKeyId: argv.bootstrapKmsKeyId,
+        },
+        versionReporting: argv.versionReporting,
+        staging: argv.staging,
+        output: argv.output,
+        outputsFile: argv.outputsFile,
+        progress: argv.progress,
+        proxy: argv.proxy,
+        bundlingStacks,
+        lookups: argv.lookups,
+        rollback: argv.rollback,
+        notices: argv.notices,
+        assetParallelism: argv['asset-parallelism'],
+        assetPrebuild: argv['asset-prebuild'],
+        ignoreNoStacks: argv['ignore-no-stacks'],
+        hotswap: {
+            ecs: {
+                minimumEcsHealthyPercent: argv.minimumEcsHealthyPercent,
+                maximumEcsHealthyPercent: argv.maximumEcsHealthyPercent,
+            },
+        },
+        unstable: argv.unstable,
+    });
+}
+function expectStringList(x) {
+    if (x === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(x)) {
+        throw new error_1.ToolkitError(`Expected array, got '${x}'`);
+    }
+    const nonStrings = x.filter((e) => typeof e !== 'string');
+    if (nonStrings.length > 0) {
+        throw new error_1.ToolkitError(`Expected list of strings, found ${nonStrings}`);
+    }
+    return x;
+}
+function parseStringContextListToObject(argv) {
+    const context = {};
+    for (const assignment of argv.context || []) {
+        const parts = assignment.split(/=(.*)/, 2);
+        if (parts.length === 2) {
+            (0, logging_1.debug)('CLI argument context: %s=%s', parts[0], parts[1]);
+            if (parts[0].match(/^aws:.+/)) {
+                throw new error_1.ToolkitError(`User-provided context cannot use keys prefixed with 'aws:', but ${parts[0]} was provided.`);
+            }
+            context[parts[0]] = parts[1];
+        }
+        else {
+            (0, logging_1.warning)('Context argument is not an assignment (key=value): %s', assignment);
+        }
+    }
+    return context;
+}
+/**
+ * Parse tags out of arguments
+ *
+ * Return undefined if no tags were provided, return an empty array if only empty
+ * strings were provided
+ */
+function parseStringTagsListToObject(argTags) {
+    if (argTags === undefined) {
+        return undefined;
+    }
+    if (argTags.length === 0) {
+        return undefined;
+    }
+    const nonEmptyTags = argTags.filter((t) => t !== '');
+    if (nonEmptyTags.length === 0) {
+        return [];
+    }
+    const tags = [];
+    for (const assignment of nonEmptyTags) {
+        const parts = assignment.split(/=(.*)/, 2);
+        if (parts.length === 2) {
+            (0, logging_1.debug)('CLI argument tags: %s=%s', parts[0], parts[1]);
+            tags.push({
+                Key: parts[0],
+                Value: parts[1],
+            });
+        }
+        else {
+            (0, logging_1.warning)('Tags argument is not an assignment (key=value): %s', assignment);
+        }
+    }
+    return tags.length > 0 ? tags : undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-configuration.js","sourceRoot":"","sources":["user-configuration.ts"],"names":[],"mappings":"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","sourcesContent":["import { Context, PROJECT_CONTEXT } from '../api/context';\nimport { Settings } from '../api/settings';\nimport { Tag } from '../api/tags';\nimport { debug, warning } from '../logging';\nimport { ToolkitError } from '../toolkit/error';\n\nexport const PROJECT_CONFIG = 'cdk.json';\nexport { PROJECT_CONTEXT } from '../api/context';\nexport const USER_DEFAULTS = '~/.cdk.json';\nconst CONTEXT_KEY = 'context';\n\nexport enum Command {\n  LS = 'ls',\n  LIST = 'list',\n  DIFF = 'diff',\n  BOOTSTRAP = 'bootstrap',\n  DEPLOY = 'deploy',\n  DESTROY = 'destroy',\n  SYNTHESIZE = 'synthesize',\n  SYNTH = 'synth',\n  METADATA = 'metadata',\n  INIT = 'init',\n  VERSION = 'version',\n  WATCH = 'watch',\n  GC = 'gc',\n  ROLLBACK = 'rollback',\n  IMPORT = 'import',\n  ACKNOWLEDGE = 'acknowledge',\n  ACK = 'ack',\n  NOTICES = 'notices',\n  MIGRATE = 'migrate',\n  CONTEXT = 'context',\n  DOCS = 'docs',\n  DOC = 'doc',\n  DOCTOR = 'doctor',\n}\n\nconst BUNDLING_COMMANDS = [\n  Command.DEPLOY,\n  Command.DIFF,\n  Command.SYNTH,\n  Command.SYNTHESIZE,\n  Command.WATCH,\n  Command.IMPORT,\n];\n\nexport type Arguments = {\n  readonly _: [Command, ...string[]];\n  readonly exclusively?: boolean;\n  readonly STACKS?: string[];\n  readonly lookups?: boolean;\n  readonly [name: string]: unknown;\n};\n\nexport interface ConfigurationProps {\n  /**\n   * Configuration passed via command line arguments\n   *\n   * @default - Nothing passed\n   */\n  readonly commandLineArguments?: Arguments;\n\n  /**\n   * Whether or not to use context from `.cdk.json` in user home directory\n   *\n   * @default true\n   */\n  readonly readUserContext?: boolean;\n}\n\n/**\n * All sources of settings combined\n */\nexport class Configuration {\n  public settings = new Settings();\n  public context = new Context();\n\n  public readonly defaultConfig = new Settings({\n    versionReporting: true,\n    assetMetadata: true,\n    pathMetadata: true,\n    output: 'cdk.out',\n  });\n\n  private readonly commandLineArguments: Settings;\n  private readonly commandLineContext: Settings;\n  private _projectConfig?: Settings;\n  private _projectContext?: Settings;\n  private loaded = false;\n\n  constructor(private readonly props: ConfigurationProps = {}) {\n    this.commandLineArguments = props.commandLineArguments\n      ? commandLineArgumentsToSettings(props.commandLineArguments)\n      : new Settings();\n    this.commandLineContext = this.commandLineArguments\n      .subSettings([CONTEXT_KEY])\n      .makeReadOnly();\n  }\n\n  private get projectConfig() {\n    if (!this._projectConfig) {\n      throw new ToolkitError('#load has not been called yet!');\n    }\n    return this._projectConfig;\n  }\n\n  public get projectContext() {\n    if (!this._projectContext) {\n      throw new ToolkitError('#load has not been called yet!');\n    }\n    return this._projectContext;\n  }\n\n  /**\n   * Load all config\n   */\n  public async load(): Promise<this> {\n    const userConfig = await loadAndLog(USER_DEFAULTS);\n    this._projectConfig = await loadAndLog(PROJECT_CONFIG);\n    this._projectContext = await loadAndLog(PROJECT_CONTEXT);\n\n    // @todo cannot currently be disabled by cli users\n    const readUserContext = this.props.readUserContext ?? true;\n\n    if (userConfig.get(['build'])) {\n      throw new ToolkitError(\n        'The `build` key cannot be specified in the user config (~/.cdk.json), specify it in the project config (cdk.json) instead',\n      );\n    }\n\n    const contextSources = [\n      { bag: this.commandLineContext },\n      {\n        fileName: PROJECT_CONFIG,\n        bag: this.projectConfig.subSettings([CONTEXT_KEY]).makeReadOnly(),\n      },\n      { fileName: PROJECT_CONTEXT, bag: this.projectContext },\n    ];\n    if (readUserContext) {\n      contextSources.push({\n        fileName: USER_DEFAULTS,\n        bag: userConfig.subSettings([CONTEXT_KEY]).makeReadOnly(),\n      });\n    }\n\n    this.context = new Context(...contextSources);\n\n    // Build settings from what's left\n    this.settings = this.defaultConfig\n      .merge(userConfig)\n      .merge(this.projectConfig)\n      .merge(this.commandLineArguments)\n      .makeReadOnly();\n\n    debug('merged settings:', this.settings.all);\n\n    this.loaded = true;\n\n    return this;\n  }\n\n  /**\n   * Save the project context\n   */\n  public async saveContext(): Promise<this> {\n    if (!this.loaded) {\n      return this;\n    } // Avoid overwriting files with nothing\n\n    await this.projectContext.save(PROJECT_CONTEXT);\n\n    return this;\n  }\n}\n\nasync function loadAndLog(fileName: string): Promise<Settings> {\n  const ret = new Settings();\n  await ret.load(fileName);\n  if (!ret.empty) {\n    debug(fileName + ':', JSON.stringify(ret.all, undefined, 2));\n  }\n  return ret;\n}\n\n/**\n * Parse CLI arguments into Settings\n *\n * CLI arguments in must be accessed in the CLI code via\n * `configuration.settings.get(['argName'])` instead of via `args.argName`.\n *\n * The advantage is that they can be configured via `cdk.json` and\n * `$HOME/.cdk.json`. Arguments not listed below and accessed via this object\n * can only be specified on the command line.\n *\n * @param argv the received CLI arguments.\n * @returns a new Settings object.\n */\nexport function commandLineArgumentsToSettings(argv: Arguments): Settings {\n  const context = parseStringContextListToObject(argv);\n  const tags = parseStringTagsListToObject(expectStringList(argv.tags));\n\n  // Determine bundling stacks\n  let bundlingStacks: string[];\n  if (BUNDLING_COMMANDS.includes(argv._[0])) {\n    // If we deploy, diff, synth or watch a list of stacks exclusively we skip\n    // bundling for all other stacks.\n    bundlingStacks = argv.exclusively ? argv.STACKS ?? ['**'] : ['**'];\n  } else {\n    // Skip bundling for all stacks\n    bundlingStacks = [];\n  }\n\n  return new Settings({\n    app: argv.app,\n    browser: argv.browser,\n    build: argv.build,\n    caBundlePath: argv.caBundlePath,\n    context,\n    debug: argv.debug,\n    tags,\n    language: argv.language,\n    pathMetadata: argv.pathMetadata,\n    assetMetadata: argv.assetMetadata,\n    profile: argv.profile,\n    plugin: argv.plugin,\n    requireApproval: argv.requireApproval,\n    toolkitStackName: argv.toolkitStackName,\n    toolkitBucket: {\n      bucketName: argv.bootstrapBucketName,\n      kmsKeyId: argv.bootstrapKmsKeyId,\n    },\n    versionReporting: argv.versionReporting,\n    staging: argv.staging,\n    output: argv.output,\n    outputsFile: argv.outputsFile,\n    progress: argv.progress,\n    proxy: argv.proxy,\n    bundlingStacks,\n    lookups: argv.lookups,\n    rollback: argv.rollback,\n    notices: argv.notices,\n    assetParallelism: argv['asset-parallelism'],\n    assetPrebuild: argv['asset-prebuild'],\n    ignoreNoStacks: argv['ignore-no-stacks'],\n    hotswap: {\n      ecs: {\n        minimumEcsHealthyPercent: argv.minimumEcsHealthyPercent,\n        maximumEcsHealthyPercent: argv.maximumEcsHealthyPercent,\n      },\n    },\n    unstable: argv.unstable,\n  });\n}\n\nfunction expectStringList(x: unknown): string[] | undefined {\n  if (x === undefined) {\n    return undefined;\n  }\n  if (!Array.isArray(x)) {\n    throw new ToolkitError(`Expected array, got '${x}'`);\n  }\n  const nonStrings = x.filter((e) => typeof e !== 'string');\n  if (nonStrings.length > 0) {\n    throw new ToolkitError(`Expected list of strings, found ${nonStrings}`);\n  }\n  return x;\n}\n\nfunction parseStringContextListToObject(argv: Arguments): any {\n  const context: any = {};\n\n  for (const assignment of (argv as any).context || []) {\n    const parts = assignment.split(/=(.*)/, 2);\n    if (parts.length === 2) {\n      debug('CLI argument context: %s=%s', parts[0], parts[1]);\n      if (parts[0].match(/^aws:.+/)) {\n        throw new ToolkitError(\n          `User-provided context cannot use keys prefixed with 'aws:', but ${parts[0]} was provided.`,\n        );\n      }\n      context[parts[0]] = parts[1];\n    } else {\n      warning(\n        'Context argument is not an assignment (key=value): %s',\n        assignment,\n      );\n    }\n  }\n  return context;\n}\n\n/**\n * Parse tags out of arguments\n *\n * Return undefined if no tags were provided, return an empty array if only empty\n * strings were provided\n */\nfunction parseStringTagsListToObject(\n  argTags: string[] | undefined,\n): Tag[] | undefined {\n  if (argTags === undefined) {\n    return undefined;\n  }\n  if (argTags.length === 0) {\n    return undefined;\n  }\n  const nonEmptyTags = argTags.filter((t) => t !== '');\n  if (nonEmptyTags.length === 0) {\n    return [];\n  }\n\n  const tags: Tag[] = [];\n\n  for (const assignment of nonEmptyTags) {\n    const parts = assignment.split(/=(.*)/, 2);\n    if (parts.length === 2) {\n      debug('CLI argument tags: %s=%s', parts[0], parts[1]);\n      tags.push({\n        Key: parts[0],\n        Value: parts[1],\n      });\n    } else {\n      warning('Tags argument is not an assignment (key=value): %s', assignment);\n    }\n  }\n  return tags.length > 0 ? tags : undefined;\n}\n"]}