aws-cdk 2.1020.2 → 2.1022.0

package/lib/init-templates/.init-version.json

@@ -1 +1 @@
-{"aws-cdk-lib": "2.202.0", "constructs": "^10.0.0"}
+{"aws-cdk-lib": "2.206.0", "constructs": "^10.0.0"}

package/lib/init-templates/.recommended-feature-flags.json

@@ -51,6 +51,7 @@
   "@aws-cdk/aws-ecs:removeDefaultDeploymentAlarm": true,
   "@aws-cdk/custom-resources:logApiResponseDataPropertyTrueDefault": false,
   "@aws-cdk/aws-s3:keepNotificationInImportedBucket": false,
+  "@aws-cdk/core:explicitStackTags": true,
   "@aws-cdk/aws-ecs:enableImdsBlockingDeprecatedFeature": false,
   "@aws-cdk/aws-ecs:disableEcsImdsBlocking": true,
   "@aws-cdk/aws-ecs:reduceEc2FargateCloudWatchPermissions": true,

package/lib/{legacy-aws-auth.d.ts → legacy/aws-auth.d.ts}

@@ -1,5 +1,5 @@
 import type { AwsCredentialIdentityProvider, Logger, NodeHttpHandlerOptions } from '@smithy/types';
-import { SdkProvider as SdkProviderCurrentVersion } from './api/aws-auth';
+import { SdkProvider as SdkProviderCurrentVersion } from '../api/aws-auth';
 /**
  * @deprecated
  */

package/lib/legacy/aws-auth.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SdkProvider = void 0;
+exports.cached = cached;
+exports.enableTracing = enableTracing;
+const aws_auth_1 = require("../api/aws-auth");
+const io_host_1 = require("../cli/io-host");
+const singleton_plugin_host_1 = require("../cli/singleton-plugin-host");
+/**
+ * @deprecated
+ */
+function cached(obj, sym, fn) {
+    if (!(sym in obj)) {
+        obj[sym] = fn();
+    }
+    return obj[sym];
+}
+/**
+ * Enable tracing in the CDK
+ *
+ * @deprecated cannot be enabled from outside the CDK
+ */
+function enableTracing(_enabled) {
+    // noop
+}
+/**
+ * @deprecated
+ */
+class SdkProvider {
+    static async withAwsCliCompatibleDefaults(options = {}) {
+        return aws_auth_1.SdkProvider.withAwsCliCompatibleDefaults({
+            ...options,
+            ioHelper: io_host_1.CliIoHost.instance().asIoHelper(),
+            pluginHost: singleton_plugin_host_1.GLOBAL_PLUGIN_HOST,
+        }, options.profile);
+    }
+    constructor(defaultCredentialProvider, defaultRegion, requestHandler = {}, logger) {
+        return new aws_auth_1.SdkProvider(defaultCredentialProvider, defaultRegion, {
+            pluginHost: singleton_plugin_host_1.GLOBAL_PLUGIN_HOST,
+            ioHelper: io_host_1.CliIoHost.instance().asIoHelper(),
+            requestHandler: requestHandler, // this is fine it's passed through to the SDK
+            logger,
+        });
+    }
+}
+exports.SdkProvider = SdkProvider;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/legacy/configuration.d.ts

@@ -0,0 +1,82 @@
+import { Context } from '../api/context';
+import { Settings } from '../api/settings';
+export declare const PROJECT_CONTEXT = "cdk.context.json";
+/**
+ * @deprecated
+ */
+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",
+    REFACTOR = "refactor",
+    DRIFT = "drift",
+    CLI_TELEMETRY = "cli-telemetry"
+}
+type Arguments = {
+    readonly _: [Command, ...string[]];
+    readonly exclusively?: boolean;
+    readonly STACKS?: string[];
+    readonly lookups?: boolean;
+    readonly [name: string]: unknown;
+};
+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
+ * @deprecated
+ */
+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>;
+}
+export {};

package/lib/legacy/configuration.js

@@ -0,0 +1,321 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Configuration = exports.Command = exports.PROJECT_CONTEXT = void 0;
+const os = require("os");
+const fs_path = require("path");
+const toolkit_lib_1 = require("@aws-cdk/toolkit-lib");
+const fs = require("fs-extra");
+const logging_1 = require("./logging");
+const context_1 = require("../api/context");
+const settings_1 = require("../api/settings");
+exports.PROJECT_CONTEXT = 'cdk.context.json';
+const PROJECT_CONFIG = 'cdk.json';
+const USER_DEFAULTS = '~/.cdk.json';
+const CONTEXT_KEY = 'context';
+/**
+ * @deprecated
+ */
+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["REFACTOR"] = "refactor";
+    Command["DRIFT"] = "drift";
+    Command["CLI_TELEMETRY"] = "cli-telemetry";
+})(Command || (exports.Command = Command = {}));
+const BUNDLING_COMMANDS = [
+    Command.DEPLOY,
+    Command.DIFF,
+    Command.SYNTH,
+    Command.SYNTHESIZE,
+    Command.WATCH,
+    Command.IMPORT,
+];
+/**
+ * All sources of settings combined
+ * @deprecated
+ */
+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 toolkit_lib_1.ToolkitError('#load has not been called yet!');
+        }
+        return this._projectConfig;
+    }
+    get projectContext() {
+        if (!this._projectContext) {
+            throw new toolkit_lib_1.ToolkitError('#load has not been called yet!');
+        }
+        return this._projectContext;
+    }
+    /**
+     * Load all config
+     */
+    async load() {
+        const userConfig = await loadAndLog(USER_DEFAULTS);
+        this._projectConfig = await loadAndLog(PROJECT_CONFIG);
+        this._projectContext = await loadAndLog(exports.PROJECT_CONTEXT);
+        // @todo cannot currently be disabled by cli users
+        const readUserContext = this.props.readUserContext ?? true;
+        if (userConfig.get(['build'])) {
+            throw new toolkit_lib_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: PROJECT_CONFIG,
+                bag: this.projectConfig.subSettings([CONTEXT_KEY]).makeReadOnly(),
+            },
+            { fileName: exports.PROJECT_CONTEXT, bag: this.projectContext },
+        ];
+        if (readUserContext) {
+            contextSources.push({
+                fileName: 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(exports.PROJECT_CONTEXT);
+        return this;
+    }
+}
+exports.Configuration = Configuration;
+async function loadAndLog(fileName) {
+    const ret = await settingsFromFile(fileName);
+    if (!ret.empty) {
+        (0, logging_1.debug)(fileName + ':', JSON.stringify(ret.all, undefined, 2));
+    }
+    return ret;
+}
+async function settingsFromFile(fileName) {
+    let settings;
+    const expanded = expandHomeDir(fileName);
+    if (await fs.pathExists(expanded)) {
+        const data = await fs.readJson(expanded);
+        settings = new settings_1.Settings(data);
+    }
+    else {
+        settings = new settings_1.Settings();
+    }
+    // See https://github.com/aws/aws-cdk/issues/59
+    prohibitContextKeys(settings, ['default-account', 'default-region'], fileName);
+    warnAboutContextKey(settings, 'aws:', fileName);
+    return settings;
+}
+function prohibitContextKeys(settings, keys, fileName) {
+    const context = settings.get(['context']);
+    if (!context || typeof context !== 'object') {
+        return;
+    }
+    for (const key of keys) {
+        if (key in context) {
+            throw new toolkit_lib_1.ToolkitError(`The 'context.${key}' key was found in ${fs_path.resolve(fileName)}, but it is no longer supported. Please remove it.`);
+        }
+    }
+}
+function warnAboutContextKey(settings, prefix, fileName) {
+    const context = settings.get(['context']);
+    if (!context || typeof context !== 'object') {
+        return;
+    }
+    for (const contextKey of Object.keys(context)) {
+        if (contextKey.startsWith(prefix)) {
+            (0, logging_1.warning)(`A reserved context key ('context.${prefix}') key was found in ${fs_path.resolve(fileName)}, it might cause surprising behavior and should be removed.`);
+        }
+    }
+}
+function expandHomeDir(x) {
+    if (x.startsWith('~')) {
+        return fs_path.join(os.homedir(), x.slice(1));
+    }
+    return x;
+}
+/**
+ * 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) {
+    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 ? argv.STACKS ?? ['**'] : ['**'];
+    }
+    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: {
+                minimumHealthyPercent: argv.hotswapEcsMinimumHealthyPercent,
+                maximumHealthyPercent: argv.hotswapEcsMaximumHealthyPercent,
+                stabilizationTimeoutSeconds: argv.hotswapEcsStabilizationTimeoutSeconds,
+            },
+        },
+        unstable: argv.unstable,
+    });
+}
+function expectStringList(x) {
+    if (x === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(x)) {
+        throw new toolkit_lib_1.ToolkitError(`Expected array, got '${x}'`);
+    }
+    const nonStrings = x.filter((e) => typeof e !== 'string');
+    if (nonStrings.length > 0) {
+        throw new toolkit_lib_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 toolkit_lib_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":"configuration.js","sourceRoot":"","sources":["configuration.ts"],"names":[],"mappings":"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","sourcesContent":["import * as os from 'os';\nimport * as fs_path from 'path';\nimport { ToolkitError } from '@aws-cdk/toolkit-lib';\nimport * as fs from 'fs-extra';\nimport { debug, warning } from './logging';\nimport { Context } from '../api/context';\nimport { Settings } from '../api/settings';\nimport type { Tag } from '../api/tags';\n\nexport const PROJECT_CONTEXT = 'cdk.context.json';\nconst PROJECT_CONFIG = 'cdk.json';\nconst USER_DEFAULTS = '~/.cdk.json';\nconst CONTEXT_KEY = 'context';\n\n/**\n * @deprecated\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  REFACTOR = 'refactor',\n  DRIFT = 'drift',\n  CLI_TELEMETRY = 'cli-telemetry',\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\ntype Arguments = {\n  readonly _: [Command, ...string[]];\n  readonly exclusively?: boolean;\n  readonly STACKS?: string[];\n  readonly lookups?: boolean;\n  readonly [name: string]: unknown;\n};\n\ninterface 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 * @deprecated\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 = await settingsFromFile(fileName);\n  if (!ret.empty) {\n    debug(fileName + ':', JSON.stringify(ret.all, undefined, 2));\n  }\n  return ret;\n}\n\nasync function settingsFromFile(fileName: string): Promise<Settings> {\n  let settings;\n  const expanded = expandHomeDir(fileName);\n  if (await fs.pathExists(expanded)) {\n    const data = await fs.readJson(expanded);\n    settings = new Settings(data);\n  } else {\n    settings = new Settings();\n  }\n\n  // See https://github.com/aws/aws-cdk/issues/59\n  prohibitContextKeys(settings, ['default-account', 'default-region'], fileName);\n  warnAboutContextKey(settings, 'aws:', fileName);\n\n  return settings;\n}\n\nfunction prohibitContextKeys(settings: Settings, keys: string[], fileName: string) {\n  const context = settings.get(['context']);\n  if (!context || typeof context !== 'object') {\n    return;\n  }\n\n  for (const key of keys) {\n    if (key in context) {\n      throw new ToolkitError(\n        `The 'context.${key}' key was found in ${fs_path.resolve(\n          fileName,\n        )}, but it is no longer supported. Please remove it.`,\n      );\n    }\n  }\n}\n\nfunction warnAboutContextKey(settings: Settings, prefix: string, fileName: string) {\n  const context = settings.get(['context']);\n  if (!context || typeof context !== 'object') {\n    return;\n  }\n\n  for (const contextKey of Object.keys(context)) {\n    if (contextKey.startsWith(prefix)) {\n      warning(\n        `A reserved context key ('context.${prefix}') key was found in ${fs_path.resolve(\n          fileName,\n        )}, it might cause surprising behavior and should be removed.`,\n      );\n    }\n  }\n}\n\nfunction expandHomeDir(x: string) {\n  if (x.startsWith('~')) {\n    return fs_path.join(os.homedir(), x.slice(1));\n  }\n  return x;\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 */\nfunction 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        minimumHealthyPercent: argv.hotswapEcsMinimumHealthyPercent,\n        maximumHealthyPercent: argv.hotswapEcsMaximumHealthyPercent,\n        stabilizationTimeoutSeconds: argv.hotswapEcsStabilizationTimeoutSeconds,\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"]}

package/lib/legacy/index.d.ts

@@ -0,0 +1,19 @@
+export type * from './types';
+export * from './logging';
+export * from './aws-auth';
+export { Command, Configuration, PROJECT_CONTEXT } from './configuration';
+export { CfnEvaluationException } from '../api/cloudformation';
+export { Deployments } from '../api/deployments';
+export { deployStack } from '../api-private';
+export { PluginHost } from '../api/plugin';
+export { Settings } from '../api/settings';
+export { Bootstrapper } from '../api/bootstrap';
+export { CloudExecutable, execProgram } from '../cxapp';
+export { cli, exec } from '../cli/cli';
+export { cliRootDir as rootDir } from '../cli/root-dir';
+export { formatAsBanner } from '../cli/util/console-formatters';
+export { versionNumber } from '../cli/version';
+export { RequireApproval } from '@aws-cdk/cloud-assembly-schema';
+export { availableInitTemplates } from '../commands/init';
+export { aliases, command, describe } from '../commands/docs';
+export { deepClone, flatten, ifDefined, isArray, isEmpty, numberFromBool, partition, padLeft as leftPad, contentHash, deepMerge, lowerCaseFirstCharacter } from '../util';