aws-cdk 0.0.0

package/lib/api/settings.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Settings = exports.TRANSIENT_CONTEXT_KEY = void 0;
+const os = require("os");
+const fs_path = require("path");
+const fs = require("fs-extra");
+const logging_1 = require("../logging");
+const error_1 = require("../toolkit/error");
+const util = require("../util/objects");
+/**
+ * If a context value is an object with this key set to a truthy value, it won't be saved to cdk.context.json
+ */
+exports.TRANSIENT_CONTEXT_KEY = '$dontSaveContext';
+/**
+ * A single bag of settings
+ */
+class Settings {
+    static mergeAll(...settings) {
+        let ret = new Settings();
+        for (const setting of settings) {
+            ret = ret.merge(setting);
+        }
+        return ret;
+    }
+    constructor(settings = {}, readOnly = false) {
+        this.settings = settings;
+        this.readOnly = readOnly;
+    }
+    async load(fileName) {
+        if (this.readOnly) {
+            throw new error_1.ToolkitError(`Can't load ${fileName}: settings object is readonly`);
+        }
+        this.settings = {};
+        const expanded = expandHomeDir(fileName);
+        if (await fs.pathExists(expanded)) {
+            this.settings = await fs.readJson(expanded);
+        }
+        // See https://github.com/aws/aws-cdk/issues/59
+        this.prohibitContextKey('default-account', fileName);
+        this.prohibitContextKey('default-region', fileName);
+        this.warnAboutContextKey('aws:', fileName);
+        return this;
+    }
+    async save(fileName) {
+        const expanded = expandHomeDir(fileName);
+        await fs.writeJson(expanded, stripTransientValues(this.settings), {
+            spaces: 2,
+        });
+        return this;
+    }
+    get all() {
+        return this.get([]);
+    }
+    merge(other) {
+        return new Settings(util.deepMerge(this.settings, other.settings));
+    }
+    subSettings(keyPrefix) {
+        return new Settings(this.get(keyPrefix) || {}, false);
+    }
+    makeReadOnly() {
+        return new Settings(this.settings, true);
+    }
+    clear() {
+        if (this.readOnly) {
+            throw new error_1.ToolkitError('Cannot clear(): settings are readonly');
+        }
+        this.settings = {};
+    }
+    get empty() {
+        return Object.keys(this.settings).length === 0;
+    }
+    get(path) {
+        return util.deepClone(util.deepGet(this.settings, path));
+    }
+    set(path, value) {
+        if (this.readOnly) {
+            throw new error_1.ToolkitError(`Can't set ${path}: settings object is readonly`);
+        }
+        if (path.length === 0) {
+            // deepSet can't handle this case
+            this.settings = value;
+        }
+        else {
+            util.deepSet(this.settings, path, value);
+        }
+        return this;
+    }
+    unset(path) {
+        this.set(path, undefined);
+    }
+    prohibitContextKey(key, fileName) {
+        if (!this.settings.context) {
+            return;
+        }
+        if (key in this.settings.context) {
+            // eslint-disable-next-line max-len
+            throw new error_1.ToolkitError(`The 'context.${key}' key was found in ${fs_path.resolve(fileName)}, but it is no longer supported. Please remove it.`);
+        }
+    }
+    warnAboutContextKey(prefix, fileName) {
+        if (!this.settings.context) {
+            return;
+        }
+        for (const contextKey of Object.keys(this.settings.context)) {
+            if (contextKey.startsWith(prefix)) {
+                // eslint-disable-next-line max-len
+                (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.`);
+            }
+        }
+    }
+}
+exports.Settings = Settings;
+function expandHomeDir(x) {
+    if (x.startsWith('~')) {
+        return fs_path.join(os.homedir(), x.slice(1));
+    }
+    return x;
+}
+/**
+ * Return all context value that are not transient context values
+ */
+function stripTransientValues(obj) {
+    const ret = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (!isTransientValue(value)) {
+            ret[key] = value;
+        }
+    }
+    return ret;
+}
+/**
+ * Return whether the given value is a transient context value
+ *
+ * Values that are objects with a magic key set to a truthy value are considered transient.
+ */
+function isTransientValue(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        value[exports.TRANSIENT_CONTEXT_KEY]);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"settings.js","sourceRoot":"","sources":["settings.ts"],"names":[],"mappings":"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","sourcesContent":["import * as os from 'os';\nimport * as fs_path from 'path';\nimport * as fs from 'fs-extra';\nimport { warning } from '../logging';\nimport { ToolkitError } from '../toolkit/error';\nimport * as util from '../util/objects';\n\nexport type SettingsMap = { [key: string]: any };\n\n/**\n * If a context value is an object with this key set to a truthy value, it won't be saved to cdk.context.json\n */\nexport const TRANSIENT_CONTEXT_KEY = '$dontSaveContext';\n\n/**\n * A single bag of settings\n */\nexport class Settings {\n  public static mergeAll(...settings: Settings[]): Settings {\n    let ret = new Settings();\n    for (const setting of settings) {\n      ret = ret.merge(setting);\n    }\n    return ret;\n  }\n\n  constructor(\n    private settings: SettingsMap = {},\n    public readonly readOnly = false,\n  ) {}\n\n  public async load(fileName: string): Promise<this> {\n    if (this.readOnly) {\n      throw new ToolkitError(\n        `Can't load ${fileName}: settings object is readonly`,\n      );\n    }\n    this.settings = {};\n\n    const expanded = expandHomeDir(fileName);\n    if (await fs.pathExists(expanded)) {\n      this.settings = await fs.readJson(expanded);\n    }\n\n    // See https://github.com/aws/aws-cdk/issues/59\n    this.prohibitContextKey('default-account', fileName);\n    this.prohibitContextKey('default-region', fileName);\n    this.warnAboutContextKey('aws:', fileName);\n\n    return this;\n  }\n\n  public async save(fileName: string): Promise<this> {\n    const expanded = expandHomeDir(fileName);\n    await fs.writeJson(expanded, stripTransientValues(this.settings), {\n      spaces: 2,\n    });\n    return this;\n  }\n\n  public get all(): any {\n    return this.get([]);\n  }\n\n  public merge(other: Settings): Settings {\n    return new Settings(util.deepMerge(this.settings, other.settings));\n  }\n\n  public subSettings(keyPrefix: string[]) {\n    return new Settings(this.get(keyPrefix) || {}, false);\n  }\n\n  public makeReadOnly(): Settings {\n    return new Settings(this.settings, true);\n  }\n\n  public clear() {\n    if (this.readOnly) {\n      throw new ToolkitError('Cannot clear(): settings are readonly');\n    }\n    this.settings = {};\n  }\n\n  public get empty(): boolean {\n    return Object.keys(this.settings).length === 0;\n  }\n\n  public get(path: string[]): any {\n    return util.deepClone(util.deepGet(this.settings, path));\n  }\n\n  public set(path: string[], value: any): Settings {\n    if (this.readOnly) {\n      throw new ToolkitError(`Can't set ${path}: settings object is readonly`);\n    }\n    if (path.length === 0) {\n      // deepSet can't handle this case\n      this.settings = value;\n    } else {\n      util.deepSet(this.settings, path, value);\n    }\n    return this;\n  }\n\n  public unset(path: string[]) {\n    this.set(path, undefined);\n  }\n\n  private prohibitContextKey(key: string, fileName: string) {\n    if (!this.settings.context) {\n      return;\n    }\n    if (key in this.settings.context) {\n      // eslint-disable-next-line max-len\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  private warnAboutContextKey(prefix: string, fileName: string) {\n    if (!this.settings.context) {\n      return;\n    }\n    for (const contextKey of Object.keys(this.settings.context)) {\n      if (contextKey.startsWith(prefix)) {\n        // eslint-disable-next-line max-len\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}\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 * Return all context value that are not transient context values\n */\nfunction stripTransientValues(obj: { [key: string]: any }) {\n  const ret: any = {};\n  for (const [key, value] of Object.entries(obj)) {\n    if (!isTransientValue(value)) {\n      ret[key] = value;\n    }\n  }\n  return ret;\n}\n\n/**\n * Return whether the given value is a transient context value\n *\n * Values that are objects with a magic key set to a truthy value are considered transient.\n */\nfunction isTransientValue(value: any) {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    (value as any)[TRANSIENT_CONTEXT_KEY]\n  );\n}\n"]}

package/lib/api/tags.d.ts

@@ -0,0 +1,9 @@
+import type * as cxapi from '@aws-cdk/cx-api';
+/**
+ * @returns an array with the tags available in the stack metadata.
+ */
+export declare function tagsForStack(stack: cxapi.CloudFormationStackArtifact): Tag[];
+export interface Tag {
+    readonly Key: string;
+    readonly Value: string;
+}

package/lib/api/tags.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tagsForStack = tagsForStack;
+/**
+ * @returns an array with the tags available in the stack metadata.
+ */
+function tagsForStack(stack) {
+    return Object.entries(stack.tags).map(([Key, Value]) => ({ Key, Value }));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFncy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInRhZ3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFLQSxvQ0FFQztBQUxEOztHQUVHO0FBQ0gsU0FBZ0IsWUFBWSxDQUFDLEtBQXdDO0lBQ25FLE9BQU8sTUFBTSxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxHQUFHLEVBQUUsS0FBSyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsRUFBRSxHQUFHLEVBQUUsS0FBSyxFQUFFLENBQUMsQ0FBQyxDQUFDO0FBQzVFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSAqIGFzIGN4YXBpIGZyb20gJ0Bhd3MtY2RrL2N4LWFwaSc7XG5cbi8qKlxuICogQHJldHVybnMgYW4gYXJyYXkgd2l0aCB0aGUgdGFncyBhdmFpbGFibGUgaW4gdGhlIHN0YWNrIG1ldGFkYXRhLlxuICovXG5leHBvcnQgZnVuY3Rpb24gdGFnc0ZvclN0YWNrKHN0YWNrOiBjeGFwaS5DbG91ZEZvcm1hdGlvblN0YWNrQXJ0aWZhY3QpOiBUYWdbXSB7XG4gIHJldHVybiBPYmplY3QuZW50cmllcyhzdGFjay50YWdzKS5tYXAoKFtLZXksIFZhbHVlXSkgPT4gKHsgS2V5LCBWYWx1ZSB9KSk7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgVGFnIHtcbiAgcmVhZG9ubHkgS2V5OiBzdHJpbmc7XG4gIHJlYWRvbmx5IFZhbHVlOiBzdHJpbmc7XG59XG4iXX0=

package/lib/api/toolkit-info.d.ts

@@ -0,0 +1,51 @@
+import * as cxapi from '@aws-cdk/cx-api';
+import type { SDK } from './aws-auth';
+import { type CloudFormationStack } from './deployments/cloudformation';
+export declare const DEFAULT_TOOLKIT_STACK_NAME = "CDKToolkit";
+/**
+ * Information on the Bootstrap stack of the environment we're deploying to.
+ *
+ * This class serves to:
+ *
+ * - Inspect the bootstrap stack, and return various properties of it for successful
+ *   asset deployment (in case of legacy-synthesized stacks).
+ * - Validate the version of the target environment, and nothing else (in case of
+ *   default-synthesized stacks).
+ *
+ * An object of this type might represent a bootstrap stack that could not be found.
+ * This is not an issue unless any members are used that require the bootstrap stack
+ * to have been found, in which case an error is thrown (default-synthesized stacks
+ * should never run into this as they don't need information from the bootstrap
+ * stack, all information is already encoded into the Cloud Assembly Manifest).
+ *
+ * Nevertheless, an instance of this class exists to serve as a cache for SSM
+ * parameter lookups (otherwise, the "bootstrap stack version" parameter would
+ * need to be read repeatedly).
+ *
+ * Called "ToolkitInfo" for historical reasons.
+ *
+ */
+export declare abstract class ToolkitInfo {
+    static determineName(overrideName?: string): string;
+    static lookup(environment: cxapi.Environment, sdk: SDK, stackName: string | undefined): Promise<ToolkitInfo>;
+    static fromStack(stack: CloudFormationStack): ToolkitInfo;
+    static bootstrapStackNotFoundInfo(stackName: string): ToolkitInfo;
+    static bootstrapStackLookupError(stackName: string, e: Error): ToolkitInfo;
+    abstract readonly found: boolean;
+    abstract readonly bucketUrl: string;
+    abstract readonly bucketName: string;
+    abstract readonly repositoryName: string;
+    abstract readonly version: number;
+    abstract readonly variant: string;
+    abstract readonly bootstrapStack: CloudFormationStack;
+    abstract readonly stackName: string;
+    constructor();
+}
+export interface EcrRepositoryInfo {
+    repositoryUri: string;
+}
+export interface EcrCredentials {
+    username: string;
+    password: string;
+    endpoint: string;
+}

package/lib/api/toolkit-info.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolkitInfo = exports.DEFAULT_TOOLKIT_STACK_NAME = void 0;
+const chalk = require("chalk");
+const logging_1 = require("../logging");
+const bootstrap_props_1 = require("./bootstrap/bootstrap-props");
+const cloudformation_1 = require("./deployments/cloudformation");
+const error_1 = require("../toolkit/error");
+exports.DEFAULT_TOOLKIT_STACK_NAME = 'CDKToolkit';
+/**
+ * Information on the Bootstrap stack of the environment we're deploying to.
+ *
+ * This class serves to:
+ *
+ * - Inspect the bootstrap stack, and return various properties of it for successful
+ *   asset deployment (in case of legacy-synthesized stacks).
+ * - Validate the version of the target environment, and nothing else (in case of
+ *   default-synthesized stacks).
+ *
+ * An object of this type might represent a bootstrap stack that could not be found.
+ * This is not an issue unless any members are used that require the bootstrap stack
+ * to have been found, in which case an error is thrown (default-synthesized stacks
+ * should never run into this as they don't need information from the bootstrap
+ * stack, all information is already encoded into the Cloud Assembly Manifest).
+ *
+ * Nevertheless, an instance of this class exists to serve as a cache for SSM
+ * parameter lookups (otherwise, the "bootstrap stack version" parameter would
+ * need to be read repeatedly).
+ *
+ * Called "ToolkitInfo" for historical reasons.
+ *
+ */
+class ToolkitInfo {
+    static determineName(overrideName) {
+        return overrideName !== null && overrideName !== void 0 ? overrideName : exports.DEFAULT_TOOLKIT_STACK_NAME;
+    }
+    static async lookup(environment, sdk, stackName) {
+        const cfn = sdk.cloudFormation();
+        stackName = ToolkitInfo.determineName(stackName);
+        try {
+            const stack = await (0, cloudformation_1.stabilizeStack)(cfn, stackName);
+            if (!stack) {
+                (0, logging_1.debug)("The environment %s doesn't have the CDK toolkit stack (%s) installed. Use %s to setup your environment for use with the toolkit.", environment.name, stackName, chalk.blue(`cdk bootstrap "${environment.name}"`));
+                return ToolkitInfo.bootstrapStackNotFoundInfo(stackName);
+            }
+            if (stack.stackStatus.isCreationFailure) {
+                // Treat a "failed to create" bootstrap stack as an absent one.
+                (0, logging_1.debug)('The environment %s has a CDK toolkit stack (%s) that failed to create. Use %s to try provisioning it again.', environment.name, stackName, chalk.blue(`cdk bootstrap "${environment.name}"`));
+                return ToolkitInfo.bootstrapStackNotFoundInfo(stackName);
+            }
+            return new ExistingToolkitInfo(stack);
+        }
+        catch (e) {
+            return ToolkitInfo.bootstrapStackLookupError(stackName, e);
+        }
+    }
+    static fromStack(stack) {
+        return new ExistingToolkitInfo(stack);
+    }
+    static bootstrapStackNotFoundInfo(stackName) {
+        return new BootstrapStackNotFoundInfo(stackName, "This deployment requires a bootstrap stack with a known name; pass '--toolkit-stack-name' or switch to using the 'DefaultStackSynthesizer' (see https://docs.aws.amazon.com/cdk/latest/guide/bootstrapping.html)");
+    }
+    static bootstrapStackLookupError(stackName, e) {
+        return new BootstrapStackNotFoundInfo(stackName, `This deployment requires a bootstrap stack with a known name, but during its lookup the following error occurred: ${e}; pass \'--toolkit-stack-name\' or switch to using the \'DefaultStackSynthesizer\' (see https://docs.aws.amazon.com/cdk/latest/guide/bootstrapping.html)`);
+    }
+    constructor() { }
+}
+exports.ToolkitInfo = ToolkitInfo;
+/**
+ * Returned when a bootstrap stack is found
+ */
+class ExistingToolkitInfo extends ToolkitInfo {
+    constructor(bootstrapStack) {
+        super();
+        this.bootstrapStack = bootstrapStack;
+        this.found = true;
+    }
+    get bucketUrl() {
+        return `https://${this.requireOutput(bootstrap_props_1.BUCKET_DOMAIN_NAME_OUTPUT)}`;
+    }
+    get bucketName() {
+        return this.requireOutput(bootstrap_props_1.BUCKET_NAME_OUTPUT);
+    }
+    get repositoryName() {
+        return this.requireOutput(bootstrap_props_1.REPOSITORY_NAME_OUTPUT);
+    }
+    get version() {
+        var _a;
+        return parseInt((_a = this.bootstrapStack.outputs[bootstrap_props_1.BOOTSTRAP_VERSION_OUTPUT]) !== null && _a !== void 0 ? _a : '0', 10);
+    }
+    get variant() {
+        var _a;
+        return (_a = this.bootstrapStack.parameters[bootstrap_props_1.BOOTSTRAP_VARIANT_PARAMETER]) !== null && _a !== void 0 ? _a : bootstrap_props_1.DEFAULT_BOOTSTRAP_VARIANT;
+    }
+    get parameters() {
+        var _a;
+        return (_a = this.bootstrapStack.parameters) !== null && _a !== void 0 ? _a : {};
+    }
+    get terminationProtection() {
+        var _a;
+        return (_a = this.bootstrapStack.terminationProtection) !== null && _a !== void 0 ? _a : false;
+    }
+    get stackName() {
+        return this.bootstrapStack.stackName;
+    }
+    /**
+     * Prepare an ECR repository for uploading to using Docker
+     *
+     */
+    requireOutput(output) {
+        if (!(output in this.bootstrapStack.outputs)) {
+            throw new error_1.ToolkitError(`The CDK toolkit stack (${this.bootstrapStack.stackName}) does not have an output named ${output}. Use 'cdk bootstrap' to correct this.`);
+        }
+        return this.bootstrapStack.outputs[output];
+    }
+}
+/**
+ * Returned when a bootstrap stack could not be found
+ *
+ * This is not an error in principle, UNTIL one of the members is called that requires
+ * the bootstrap stack to have been found, in which case the lookup error is still thrown
+ * belatedly.
+ *
+ * The errors below serve as a last stop-gap message--normally calling code should have
+ * checked `toolkit.found` and produced an appropriate error message.
+ */
+class BootstrapStackNotFoundInfo extends ToolkitInfo {
+    constructor(stackName, errorMessage) {
+        super();
+        this.stackName = stackName;
+        this.errorMessage = errorMessage;
+        this.found = false;
+    }
+    get bootstrapStack() {
+        throw new error_1.ToolkitError(this.errorMessage);
+    }
+    get bucketUrl() {
+        throw new error_1.ToolkitError(this.errorMessage);
+    }
+    get bucketName() {
+        throw new error_1.ToolkitError(this.errorMessage);
+    }
+    get repositoryName() {
+        throw new error_1.ToolkitError(this.errorMessage);
+    }
+    get version() {
+        throw new error_1.ToolkitError(this.errorMessage);
+    }
+    get variant() {
+        throw new error_1.ToolkitError(this.errorMessage);
+    }
+    prepareEcrRepository() {
+        throw new error_1.ToolkitError(this.errorMessage);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toolkit-info.js","sourceRoot":"","sources":["toolkit-info.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cxapi from '@aws-cdk/cx-api';\nimport * as chalk from 'chalk';\nimport type { SDK } from './aws-auth';\nimport { debug } from '../logging';\nimport {\n  BOOTSTRAP_VARIANT_PARAMETER,\n  BOOTSTRAP_VERSION_OUTPUT,\n  BUCKET_DOMAIN_NAME_OUTPUT,\n  BUCKET_NAME_OUTPUT,\n  DEFAULT_BOOTSTRAP_VARIANT,\n  REPOSITORY_NAME_OUTPUT,\n} from './bootstrap/bootstrap-props';\nimport { type CloudFormationStack, stabilizeStack } from './deployments/cloudformation';\nimport { ToolkitError } from '../toolkit/error';\n\nexport const DEFAULT_TOOLKIT_STACK_NAME = 'CDKToolkit';\n\n/**\n * Information on the Bootstrap stack of the environment we're deploying to.\n *\n * This class serves to:\n *\n * - Inspect the bootstrap stack, and return various properties of it for successful\n *   asset deployment (in case of legacy-synthesized stacks).\n * - Validate the version of the target environment, and nothing else (in case of\n *   default-synthesized stacks).\n *\n * An object of this type might represent a bootstrap stack that could not be found.\n * This is not an issue unless any members are used that require the bootstrap stack\n * to have been found, in which case an error is thrown (default-synthesized stacks\n * should never run into this as they don't need information from the bootstrap\n * stack, all information is already encoded into the Cloud Assembly Manifest).\n *\n * Nevertheless, an instance of this class exists to serve as a cache for SSM\n * parameter lookups (otherwise, the \"bootstrap stack version\" parameter would\n * need to be read repeatedly).\n *\n * Called \"ToolkitInfo\" for historical reasons.\n *\n */\nexport abstract class ToolkitInfo {\n  public static determineName(overrideName?: string) {\n    return overrideName ?? DEFAULT_TOOLKIT_STACK_NAME;\n  }\n\n  public static async lookup(\n    environment: cxapi.Environment,\n    sdk: SDK,\n    stackName: string | undefined,\n  ): Promise<ToolkitInfo> {\n    const cfn = sdk.cloudFormation();\n    stackName = ToolkitInfo.determineName(stackName);\n    try {\n      const stack = await stabilizeStack(cfn, stackName);\n      if (!stack) {\n        debug(\n          \"The environment %s doesn't have the CDK toolkit stack (%s) installed. Use %s to setup your environment for use with the toolkit.\",\n          environment.name,\n          stackName,\n          chalk.blue(`cdk bootstrap \"${environment.name}\"`),\n        );\n        return ToolkitInfo.bootstrapStackNotFoundInfo(stackName);\n      }\n      if (stack.stackStatus.isCreationFailure) {\n        // Treat a \"failed to create\" bootstrap stack as an absent one.\n        debug(\n          'The environment %s has a CDK toolkit stack (%s) that failed to create. Use %s to try provisioning it again.',\n          environment.name,\n          stackName,\n          chalk.blue(`cdk bootstrap \"${environment.name}\"`),\n        );\n        return ToolkitInfo.bootstrapStackNotFoundInfo(stackName);\n      }\n\n      return new ExistingToolkitInfo(stack);\n    } catch (e: any) {\n      return ToolkitInfo.bootstrapStackLookupError(stackName, e);\n    }\n  }\n\n  public static fromStack(stack: CloudFormationStack): ToolkitInfo {\n    return new ExistingToolkitInfo(stack);\n  }\n\n  public static bootstrapStackNotFoundInfo(stackName: string): ToolkitInfo {\n    return new BootstrapStackNotFoundInfo(\n      stackName,\n      \"This deployment requires a bootstrap stack with a known name; pass '--toolkit-stack-name' or switch to using the 'DefaultStackSynthesizer' (see https://docs.aws.amazon.com/cdk/latest/guide/bootstrapping.html)\",\n    );\n  }\n\n  public static bootstrapStackLookupError(stackName: string, e: Error): ToolkitInfo {\n    return new BootstrapStackNotFoundInfo(\n      stackName,\n      `This deployment requires a bootstrap stack with a known name, but during its lookup the following error occurred: ${e}; pass \\'--toolkit-stack-name\\' or switch to using the \\'DefaultStackSynthesizer\\' (see https://docs.aws.amazon.com/cdk/latest/guide/bootstrapping.html)`,\n    );\n  }\n\n  public abstract readonly found: boolean;\n  public abstract readonly bucketUrl: string;\n  public abstract readonly bucketName: string;\n  public abstract readonly repositoryName: string;\n  public abstract readonly version: number;\n  public abstract readonly variant: string;\n  public abstract readonly bootstrapStack: CloudFormationStack;\n  public abstract readonly stackName: string;\n\n  constructor() {}\n}\n\n/**\n * Returned when a bootstrap stack is found\n */\nclass ExistingToolkitInfo extends ToolkitInfo {\n  public readonly found = true;\n\n  constructor(public readonly bootstrapStack: CloudFormationStack) {\n    super();\n  }\n\n  public get bucketUrl() {\n    return `https://${this.requireOutput(BUCKET_DOMAIN_NAME_OUTPUT)}`;\n  }\n\n  public get bucketName() {\n    return this.requireOutput(BUCKET_NAME_OUTPUT);\n  }\n\n  public get repositoryName() {\n    return this.requireOutput(REPOSITORY_NAME_OUTPUT);\n  }\n\n  public get version() {\n    return parseInt(this.bootstrapStack.outputs[BOOTSTRAP_VERSION_OUTPUT] ?? '0', 10);\n  }\n\n  public get variant() {\n    return this.bootstrapStack.parameters[BOOTSTRAP_VARIANT_PARAMETER] ?? DEFAULT_BOOTSTRAP_VARIANT;\n  }\n\n  public get parameters(): Record<string, string> {\n    return this.bootstrapStack.parameters ?? {};\n  }\n\n  public get terminationProtection(): boolean {\n    return this.bootstrapStack.terminationProtection ?? false;\n  }\n\n  public get stackName(): string {\n    return this.bootstrapStack.stackName;\n  }\n\n  /**\n   * Prepare an ECR repository for uploading to using Docker\n   *\n   */\n  private requireOutput(output: string): string {\n    if (!(output in this.bootstrapStack.outputs)) {\n      throw new ToolkitError(\n        `The CDK toolkit stack (${this.bootstrapStack.stackName}) does not have an output named ${output}. Use 'cdk bootstrap' to correct this.`,\n      );\n    }\n    return this.bootstrapStack.outputs[output];\n  }\n}\n\n/**\n * Returned when a bootstrap stack could not be found\n *\n * This is not an error in principle, UNTIL one of the members is called that requires\n * the bootstrap stack to have been found, in which case the lookup error is still thrown\n * belatedly.\n *\n * The errors below serve as a last stop-gap message--normally calling code should have\n * checked `toolkit.found` and produced an appropriate error message.\n */\nclass BootstrapStackNotFoundInfo extends ToolkitInfo {\n  public readonly found = false;\n\n  constructor(\n    public readonly stackName: string,\n    private readonly errorMessage: string,\n  ) {\n    super();\n  }\n\n  public get bootstrapStack(): CloudFormationStack {\n    throw new ToolkitError(this.errorMessage);\n  }\n\n  public get bucketUrl(): string {\n    throw new ToolkitError(this.errorMessage);\n  }\n\n  public get bucketName(): string {\n    throw new ToolkitError(this.errorMessage);\n  }\n\n  public get repositoryName(): string {\n    throw new ToolkitError(this.errorMessage);\n  }\n\n  public get version(): number {\n    throw new ToolkitError(this.errorMessage);\n  }\n\n  public get variant(): string {\n    throw new ToolkitError(this.errorMessage);\n  }\n\n  public prepareEcrRepository(): Promise<EcrRepositoryInfo> {\n    throw new ToolkitError(this.errorMessage);\n  }\n}\n\nexport interface EcrRepositoryInfo {\n  repositoryUri: string;\n}\n\nexport interface EcrCredentials {\n  username: string;\n  password: string;\n  endpoint: string;\n}\n"]}

package/lib/api/util/cloudformation/stack-activity-monitor.d.ts

@@ -0,0 +1,237 @@
+import { type MetadataEntry } from '@aws-cdk/cloud-assembly-schema';
+import type { CloudFormationStackArtifact } from '@aws-cdk/cx-api';
+import { ResourceEvent, StackEventPoller } from './stack-event-poller';
+import { IoMessageLevel } from '../../../toolkit/cli-io-host';
+import type { ICloudFormationClient } from '../../aws-auth';
+export interface StackActivity extends ResourceEvent {
+    readonly metadata?: ResourceMetadata;
+}
+export interface ResourceMetadata {
+    entry: MetadataEntry;
+    constructPath: string;
+}
+/**
+ * Supported display modes for stack deployment activity
+ */
+export declare enum StackActivityProgress {
+    /**
+     * Displays a progress bar with only the events for the resource currently being deployed
+     */
+    BAR = "bar",
+    /**
+     * Displays complete history with all CloudFormation stack events
+     */
+    EVENTS = "events"
+}
+export interface WithDefaultPrinterProps {
+    /**
+     * Total number of resources to update
+     *
+     * Used to calculate a progress bar.
+     *
+     * @default - No progress reporting.
+     */
+    readonly resourcesTotal?: number;
+    /**
+     * The log level that was requested in the CLI
+     *
+     * If verbose or trace is requested, we'll always use the full history printer.
+     *
+     * @default - Use value from logging.logLevel
+     */
+    readonly logLevel?: IoMessageLevel;
+    /**
+     * Whether to display all stack events or to display only the events for the
+     * resource currently being deployed
+     *
+     * If not set, the stack history with all stack events will be displayed
+     *
+     * @default false
+     */
+    progress?: StackActivityProgress;
+    /**
+     * Whether we are on a CI system
+     *
+     * If so, disable the "optimized" stack monitor.
+     *
+     * @default false
+     */
+    readonly ci?: boolean;
+    /**
+     * Creation time of the change set
+     *
+     * This will be used to filter events, only showing those from after the change
+     * set creation time.
+     *
+     * It is recommended to use this, otherwise the filtering will be subject
+     * to clock drift between local and cloud machines.
+     *
+     * @default - local machine's current time
+     */
+    readonly changeSetCreationTime?: Date;
+}
+export declare class StackActivityMonitor {
+    private readonly stackName;
+    private readonly printer;
+    private readonly stack?;
+    /**
+     * Create a Stack Activity Monitor using a default printer, based on context clues
+     */
+    static withDefaultPrinter(cfn: ICloudFormationClient, stackName: string, stackArtifact: CloudFormationStackArtifact, options?: WithDefaultPrinterProps): StackActivityMonitor;
+    /**
+     * The poller used to read stack events
+     */
+    readonly poller: StackEventPoller;
+    readonly errors: string[];
+    private active;
+    /**
+     * Current tick timer
+     */
+    private tickTimer?;
+    /**
+     * Set to the activity of reading the current events
+     */
+    private readPromise?;
+    constructor(cfn: ICloudFormationClient, stackName: string, printer: IActivityPrinter, stack?: CloudFormationStackArtifact | undefined, changeSetCreationTime?: Date);
+    start(): this;
+    stop(): Promise<void>;
+    private scheduleNextTick;
+    private tick;
+    private findMetadataFor;
+    /**
+     * Reads all new events from the stack history
+     *
+     * The events are returned in reverse chronological order; we continue to the next page if we
+     * see a next page and the last event in the page is new to us (and within the time window).
+     * haven't seen the final event
+     */
+    private readNewEvents;
+    /**
+     * Perform a final poll to the end and flush out all events to the printer
+     *
+     * Finish any poll currently in progress, then do a final one until we've
+     * reached the last page.
+     */
+    private finalPollToEnd;
+    private checkForErrors;
+    private simplifyConstructPath;
+}
+interface PrinterProps {
+    /**
+     * Total resources to deploy
+     */
+    readonly resourcesTotal?: number;
+    /**
+     * The with of the "resource type" column.
+     */
+    readonly resourceTypeColumnWidth: number;
+    /**
+     * Stream to write to
+     */
+    readonly stream: NodeJS.WriteStream;
+}
+export interface IActivityPrinter {
+    readonly updateSleep: number;
+    addActivity(activity: StackActivity): void;
+    print(): void;
+    start(): void;
+    stop(): void;
+}
+declare abstract class ActivityPrinterBase implements IActivityPrinter {
+    protected readonly props: PrinterProps;
+    /**
+     * Fetch new activity every 5 seconds
+     */
+    readonly updateSleep: number;
+    /**
+     * A list of resource IDs which are currently being processed
+     */
+    protected resourcesInProgress: Record<string, StackActivity>;
+    /**
+     * Previous completion state observed by logical ID
+     *
+     * We use this to detect that if we see a DELETE_COMPLETE after a
+     * CREATE_COMPLETE, it's actually a rollback and we should DECREASE
+     * resourcesDone instead of increase it
+     */
+    protected resourcesPrevCompleteState: Record<string, string>;
+    /**
+     * Count of resources that have reported a _COMPLETE status
+     */
+    protected resourcesDone: number;
+    /**
+     * How many digits we need to represent the total count (for lining up the status reporting)
+     */
+    protected readonly resourceDigits: number;
+    protected readonly resourcesTotal?: number;
+    protected rollingBack: boolean;
+    protected readonly failures: StackActivity[];
+    protected hookFailureMap: Map<string, Map<string, string>>;
+    constructor(props: PrinterProps);
+    failureReason(activity: StackActivity): string;
+    addActivity(activity: StackActivity): void;
+    abstract print(): void;
+    start(): void;
+    stop(): void;
+}
+/**
+ * Activity Printer which shows a full log of all CloudFormation events
+ *
+ * When there hasn't been activity for a while, it will print the resources
+ * that are currently in progress, to show what's holding up the deployment.
+ */
+export declare class HistoryActivityPrinter extends ActivityPrinterBase {
+    /**
+     * Last time we printed something to the console.
+     *
+     * Used to measure timeout for progress reporting.
+     */
+    private lastPrintTime;
+    /**
+     * Number of ms of change absence before we tell the user about the resources that are currently in progress.
+     */
+    private readonly inProgressDelay;
+    private readonly printable;
+    constructor(props: PrinterProps);
+    addActivity(activity: StackActivity): void;
+    print(): void;
+    stop(): void;
+    private printOne;
+    /**
+     * Report the current progress as a [34/42] string, or just [34] if the total is unknown
+     */
+    private progress;
+    /**
+     * If some resources are taking a while to create, notify the user about what's currently in progress
+     */
+    private printInProgress;
+}
+/**
+ * Activity Printer which shows the resources currently being updated
+ *
+ * It will continuously reupdate the terminal and show only the resources
+ * that are currently being updated, in addition to a progress bar which
+ * shows how far along the deployment is.
+ *
+ * Resources that have failed will always be shown, and will be recapitulated
+ * along with their stack trace when the monitoring ends.
+ *
+ * Resources that failed deployment because they have been cancelled are
+ * not included.
+ */
+export declare class CurrentActivityPrinter extends ActivityPrinterBase {
+    /**
+     * This looks very disorienting sleeping for 5 seconds. Update quicker.
+     */
+    readonly updateSleep: number;
+    private oldLogThreshold;
+    private readonly stream;
+    private block;
+    constructor(props: PrinterProps);
+    print(): void;
+    start(): void;
+    stop(): void;
+    private progressBar;
+    private failureReasonOnNextLine;
+}
+export {};