@aws-cdk/toolkit-lib 0.3.2 → 0.3.4

package/lib/api/stack-events/stack-progress-monitor.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StackProgressMonitor = void 0;
+const util = require("util");
+const util_1 = require("../../util");
+/**
+ * Monitors stack progress.s
+ */
+class StackProgressMonitor {
+    /**
+     * 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
+     */
+    resourcesPrevCompleteState = {};
+    /**
+     * Count of resources that have reported a _COMPLETE status
+     */
+    resourcesDone = 0;
+    /**
+     * How many digits we need to represent the total count (for lining up the status reporting)
+     */
+    resourceDigits = 0;
+    /**
+     * Number of expected resources in the monitor.
+     */
+    resourcesTotal;
+    constructor(resourcesTotal) {
+        // +1 because the stack also emits a "COMPLETE" event at the end, and that wasn't
+        // counted yet. This makes it line up with the amount of events we expect.
+        this.resourcesTotal = resourcesTotal ? resourcesTotal + 1 : undefined;
+        // How many digits does this number take to represent?
+        this.resourceDigits = this.resourcesTotal ? Math.ceil(Math.log10(this.resourcesTotal)) : 0;
+    }
+    /**
+     * Report the stack progress
+     */
+    get progress() {
+        return {
+            total: this.total,
+            completed: this.completed,
+            formatted: this.formatted,
+        };
+    }
+    /**
+     * The total number of progress monitored resources.
+     */
+    get total() {
+        return this.resourcesTotal;
+    }
+    /**
+     * The number of completed resources.
+     */
+    get completed() {
+        return this.resourcesDone;
+    }
+    /**
+     * Report the current progress as a [34/42] string, or just [34] if the total is unknown
+     */
+    get formatted() {
+        if (this.resourcesTotal == null) {
+            // Don't have total, show simple count and hope the human knows
+            return (0, util_1.padLeft)(3, util.format('%s', this.resourcesDone)); // max 500 resources
+        }
+        return util.format('%s/%s', (0, util_1.padLeft)(this.resourceDigits, this.resourcesDone.toString()), (0, util_1.padLeft)(this.resourceDigits, this.resourcesTotal.toString()));
+    }
+    /**
+     * Process as stack event and update the progress state.
+     */
+    process(event) {
+        const status = event.ResourceStatus;
+        if (!status || !event.LogicalResourceId) {
+            return;
+        }
+        if (status.endsWith('_COMPLETE_CLEANUP_IN_PROGRESS')) {
+            this.resourcesDone++;
+        }
+        if (status.endsWith('_COMPLETE')) {
+            const prevState = this.resourcesPrevCompleteState[event.LogicalResourceId];
+            if (!prevState) {
+                this.resourcesDone++;
+            }
+            else {
+                // If we completed this before and we're completing it AGAIN, means we're rolling back.
+                // Protect against silly underflow.
+                this.resourcesDone--;
+                if (this.resourcesDone < 0) {
+                    this.resourcesDone = 0;
+                }
+            }
+            this.resourcesPrevCompleteState[event.LogicalResourceId] = status;
+        }
+    }
+}
+exports.StackProgressMonitor = StackProgressMonitor;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/stack-events/stack-status.d.ts

@@ -0,0 +1,42 @@
+import { type Stack } from '@aws-sdk/client-cloudformation';
+/**
+ * A utility class to inspect CloudFormation stack statuses.
+ *
+ * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-describing-stacks.html
+ */
+export declare class StackStatus {
+    readonly name: string;
+    readonly reason?: string | undefined;
+    static fromStackDescription(description: Stack): StackStatus;
+    constructor(name: string, reason?: string | undefined);
+    get isCreationFailure(): boolean;
+    get isDeleted(): boolean;
+    get isFailure(): boolean;
+    get isInProgress(): boolean;
+    get isReviewInProgress(): boolean;
+    get isNotFound(): boolean;
+    get isDeploySuccess(): boolean;
+    get isRollbackSuccess(): boolean;
+    /**
+     * Whether the stack is in a paused state due to `--no-rollback`.
+     *
+     * The possible actions here are retrying a new `--no-rollback` deployment, or initiating a rollback.
+     */
+    get rollbackChoice(): RollbackChoice;
+    get isRollbackable(): boolean;
+    toString(): string;
+}
+/**
+ * Describe the current rollback options for this state
+ */
+export declare enum RollbackChoice {
+    START_ROLLBACK = 0,
+    CONTINUE_UPDATE_ROLLBACK = 1,
+    /**
+     * A sign that stack creation AND its rollback have failed.
+     *
+     * There is no way to recover from this, other than recreating the stack.
+     */
+    ROLLBACK_FAILED = 2,
+    NONE = 3
+}

package/lib/api/stack-events/stack-status.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RollbackChoice = exports.StackStatus = void 0;
+const client_cloudformation_1 = require("@aws-sdk/client-cloudformation");
+/**
+ * A utility class to inspect CloudFormation stack statuses.
+ *
+ * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-describing-stacks.html
+ */
+class StackStatus {
+    name;
+    reason;
+    static fromStackDescription(description) {
+        return new StackStatus(description.StackStatus, description.StackStatusReason);
+    }
+    constructor(name, reason) {
+        this.name = name;
+        this.reason = reason;
+    }
+    get isCreationFailure() {
+        return this.name === client_cloudformation_1.StackStatus.ROLLBACK_COMPLETE || this.name === client_cloudformation_1.StackStatus.ROLLBACK_FAILED;
+    }
+    get isDeleted() {
+        return this.name.startsWith('DELETE_');
+    }
+    get isFailure() {
+        return this.name.endsWith('FAILED');
+    }
+    get isInProgress() {
+        return this.name.endsWith('_IN_PROGRESS') && !this.isReviewInProgress;
+    }
+    get isReviewInProgress() {
+        return this.name === client_cloudformation_1.StackStatus.REVIEW_IN_PROGRESS;
+    }
+    get isNotFound() {
+        return this.name === 'NOT_FOUND';
+    }
+    get isDeploySuccess() {
+        return (!this.isNotFound &&
+            (this.name === client_cloudformation_1.StackStatus.CREATE_COMPLETE ||
+                this.name === client_cloudformation_1.StackStatus.UPDATE_COMPLETE ||
+                this.name === client_cloudformation_1.StackStatus.IMPORT_COMPLETE));
+    }
+    get isRollbackSuccess() {
+        return this.name === client_cloudformation_1.StackStatus.ROLLBACK_COMPLETE || this.name === client_cloudformation_1.StackStatus.UPDATE_ROLLBACK_COMPLETE;
+    }
+    /**
+     * Whether the stack is in a paused state due to `--no-rollback`.
+     *
+     * The possible actions here are retrying a new `--no-rollback` deployment, or initiating a rollback.
+     */
+    get rollbackChoice() {
+        switch (this.name) {
+            case client_cloudformation_1.StackStatus.CREATE_FAILED:
+            case client_cloudformation_1.StackStatus.UPDATE_FAILED:
+                return RollbackChoice.START_ROLLBACK;
+            case client_cloudformation_1.StackStatus.UPDATE_ROLLBACK_FAILED:
+                return RollbackChoice.CONTINUE_UPDATE_ROLLBACK;
+            case client_cloudformation_1.StackStatus.ROLLBACK_FAILED:
+                // Unfortunately there is no option to continue a failed rollback without
+                // a stable target state.
+                return RollbackChoice.ROLLBACK_FAILED;
+            default:
+                return RollbackChoice.NONE;
+        }
+    }
+    get isRollbackable() {
+        return [RollbackChoice.START_ROLLBACK, RollbackChoice.CONTINUE_UPDATE_ROLLBACK].includes(this.rollbackChoice);
+    }
+    toString() {
+        return this.name + (this.reason ? ` (${this.reason})` : '');
+    }
+}
+exports.StackStatus = StackStatus;
+/**
+ * Describe the current rollback options for this state
+ */
+var RollbackChoice;
+(function (RollbackChoice) {
+    RollbackChoice[RollbackChoice["START_ROLLBACK"] = 0] = "START_ROLLBACK";
+    RollbackChoice[RollbackChoice["CONTINUE_UPDATE_ROLLBACK"] = 1] = "CONTINUE_UPDATE_ROLLBACK";
+    /**
+     * A sign that stack creation AND its rollback have failed.
+     *
+     * There is no way to recover from this, other than recreating the stack.
+     */
+    RollbackChoice[RollbackChoice["ROLLBACK_FAILED"] = 2] = "ROLLBACK_FAILED";
+    RollbackChoice[RollbackChoice["NONE"] = 3] = "NONE";
+})(RollbackChoice || (exports.RollbackChoice = RollbackChoice = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/streams.d.ts

@@ -0,0 +1,7 @@
+import { Writable } from 'node:stream';
+export declare class StringWriteStream extends Writable {
+    private buffer;
+    constructor();
+    _write(chunk: any, _encoding: string, callback: (error?: Error | null) => void): void;
+    toString(): string;
+}

package/lib/api/streams.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringWriteStream = void 0;
+const node_stream_1 = require("node:stream");
+/*
+ * Custom writable stream that collects text into a string buffer.
+ * Used on classes that take in and directly write to a stream, but
+ * we intend to capture the output rather than print.
+ */
+class StringWriteStream extends node_stream_1.Writable {
+    buffer = [];
+    constructor() {
+        super();
+    }
+    _write(chunk, _encoding, callback) {
+        this.buffer.push(chunk.toString());
+        callback();
+    }
+    toString() {
+        return this.buffer.join('');
+    }
+}
+exports.StringWriteStream = StringWriteStream;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RyZWFtcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInN0cmVhbXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsNkNBQXVDO0FBRXZDOzs7O0dBSUc7QUFDSCxNQUFhLGlCQUFrQixTQUFRLHNCQUFRO0lBQ3JDLE1BQU0sR0FBYSxFQUFFLENBQUM7SUFFOUI7UUFDRSxLQUFLLEVBQUUsQ0FBQztJQUNWLENBQUM7SUFFRCxNQUFNLENBQUMsS0FBVSxFQUFFLFNBQWlCLEVBQUUsUUFBd0M7UUFDNUUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUM7UUFDbkMsUUFBUSxFQUFFLENBQUM7SUFDYixDQUFDO0lBRUQsUUFBUTtRQUNOLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDOUIsQ0FBQztDQUNGO0FBZkQsOENBZUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBXcml0YWJsZSB9IGZyb20gJ25vZGU6c3RyZWFtJztcblxuLypcbiAqIEN1c3RvbSB3cml0YWJsZSBzdHJlYW0gdGhhdCBjb2xsZWN0cyB0ZXh0IGludG8gYSBzdHJpbmcgYnVmZmVyLlxuICogVXNlZCBvbiBjbGFzc2VzIHRoYXQgdGFrZSBpbiBhbmQgZGlyZWN0bHkgd3JpdGUgdG8gYSBzdHJlYW0sIGJ1dFxuICogd2UgaW50ZW5kIHRvIGNhcHR1cmUgdGhlIG91dHB1dCByYXRoZXIgdGhhbiBwcmludC5cbiAqL1xuZXhwb3J0IGNsYXNzIFN0cmluZ1dyaXRlU3RyZWFtIGV4dGVuZHMgV3JpdGFibGUge1xuICBwcml2YXRlIGJ1ZmZlcjogc3RyaW5nW10gPSBbXTtcblxuICBjb25zdHJ1Y3RvcigpIHtcbiAgICBzdXBlcigpO1xuICB9XG5cbiAgX3dyaXRlKGNodW5rOiBhbnksIF9lbmNvZGluZzogc3RyaW5nLCBjYWxsYmFjazogKGVycm9yPzogRXJyb3IgfCBudWxsKSA9PiB2b2lkKTogdm9pZCB7XG4gICAgdGhpcy5idWZmZXIucHVzaChjaHVuay50b1N0cmluZygpKTtcbiAgICBjYWxsYmFjaygpO1xuICB9XG5cbiAgdG9TdHJpbmcoKTogc3RyaW5nIHtcbiAgICByZXR1cm4gdGhpcy5idWZmZXIuam9pbignJyk7XG4gIH1cbn1cbiJdfQ==

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,52 @@
+import type * as cxapi from '@aws-cdk/cx-api';
+import type { SDK } from './aws-auth/private';
+import type { CloudFormationStack } from './cloudformation';
+import { type IoHelper } from './io/private';
+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, ioHelper: IoHelper, 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,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolkitInfo = exports.DEFAULT_TOOLKIT_STACK_NAME = void 0;
+const util_1 = require("util");
+const chalk = require("chalk");
+const bootstrap_props_1 = require("./bootstrap/bootstrap-props");
+const toolkit_error_1 = require("../toolkit/toolkit-error");
+const cfn_api_1 = require("./deployments/cfn-api");
+const private_1 = require("./io/private");
+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 ?? exports.DEFAULT_TOOLKIT_STACK_NAME;
+    }
+    static async lookup(environment, sdk, ioHelper, stackName) {
+        const cfn = sdk.cloudFormation();
+        stackName = ToolkitInfo.determineName(stackName);
+        try {
+            const stack = await (0, cfn_api_1.stabilizeStack)(cfn, ioHelper, stackName);
+            if (!stack) {
+                await ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg((0, util_1.format)("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.
+                await ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg((0, util_1.format)('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 {
+    bootstrapStack;
+    found = true;
+    constructor(bootstrapStack) {
+        super();
+        this.bootstrapStack = bootstrapStack;
+    }
+    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() {
+        return parseInt(this.bootstrapStack.outputs[bootstrap_props_1.BOOTSTRAP_VERSION_OUTPUT] ?? '0', 10);
+    }
+    get variant() {
+        return this.bootstrapStack.parameters[bootstrap_props_1.BOOTSTRAP_VARIANT_PARAMETER] ?? bootstrap_props_1.DEFAULT_BOOTSTRAP_VARIANT;
+    }
+    get parameters() {
+        return this.bootstrapStack.parameters ?? {};
+    }
+    get terminationProtection() {
+        return this.bootstrapStack.terminationProtection ?? 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 toolkit_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 {
+    stackName;
+    errorMessage;
+    found = false;
+    constructor(stackName, errorMessage) {
+        super();
+        this.stackName = stackName;
+        this.errorMessage = errorMessage;
+    }
+    get bootstrapStack() {
+        throw new toolkit_error_1.ToolkitError(this.errorMessage);
+    }
+    get bucketUrl() {
+        throw new toolkit_error_1.ToolkitError(this.errorMessage);
+    }
+    get bucketName() {
+        throw new toolkit_error_1.ToolkitError(this.errorMessage);
+    }
+    get repositoryName() {
+        throw new toolkit_error_1.ToolkitError(this.errorMessage);
+    }
+    get version() {
+        throw new toolkit_error_1.ToolkitError(this.errorMessage);
+    }
+    get variant() {
+        throw new toolkit_error_1.ToolkitError(this.errorMessage);
+    }
+    prepareEcrRepository() {
+        throw new toolkit_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 { format } from 'util';\nimport type * as cxapi from '@aws-cdk/cx-api';\nimport * as chalk from 'chalk';\nimport type { SDK } from './aws-auth/private';\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 } from './cloudformation';\nimport { ToolkitError } from '../toolkit/toolkit-error';\nimport { stabilizeStack } from './deployments/cfn-api';\nimport { IO, type IoHelper } from './io/private';\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    ioHelper: IoHelper,\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, ioHelper, stackName);\n      if (!stack) {\n        await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(\n          format(\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        ));\n        return ToolkitInfo.bootstrapStackNotFoundInfo(stackName);\n      }\n      if (stack.stackStatus.isCreationFailure) {\n        // Treat a \"failed to create\" bootstrap stack as an absent one.\n        await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(\n          format(\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        ));\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/**\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/tree.d.ts

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

package/lib/api/tree.js

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

package/lib/api/work-graph/index.d.ts

@@ -0,0 +1,3 @@
+export * from './work-graph';
+export * from './work-graph-builder';
+export * from './work-graph-types';