@aws-cdk/toolkit-lib 0.3.1 → 0.3.3

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

@@ -0,0 +1,4 @@
+export * from './stack-activity-monitor';
+export * from './stack-event-poller';
+export * from './stack-status';
+export { StackProgressMonitor } from './stack-progress-monitor';

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

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StackProgressMonitor = void 0;
+__exportStar(require("./stack-activity-monitor"), exports);
+__exportStar(require("./stack-event-poller"), exports);
+__exportStar(require("./stack-status"), exports);
+var stack_progress_monitor_1 = require("./stack-progress-monitor");
+Object.defineProperty(exports, "StackProgressMonitor", { enumerable: true, get: function () { return stack_progress_monitor_1.StackProgressMonitor; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDJEQUF5QztBQUN6Qyx1REFBcUM7QUFDckMsaURBQStCO0FBRS9CLG1FQUFnRTtBQUF2RCw4SEFBQSxvQkFBb0IsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc3RhY2stYWN0aXZpdHktbW9uaXRvcic7XG5leHBvcnQgKiBmcm9tICcuL3N0YWNrLWV2ZW50LXBvbGxlcic7XG5leHBvcnQgKiBmcm9tICcuL3N0YWNrLXN0YXR1cyc7XG5cbmV4cG9ydCB7IFN0YWNrUHJvZ3Jlc3NNb25pdG9yIH0gZnJvbSAnLi9zdGFjay1wcm9ncmVzcy1tb25pdG9yJztcbiJdfQ==

package/lib/api/stack-events/stack-activity-monitor.d.ts

@@ -0,0 +1,100 @@
+import type { CloudFormationStackArtifact } from '@aws-cdk/cx-api';
+import type { ICloudFormationClient } from '../aws-auth/private';
+import { type IoHelper } from '../io/private';
+export interface StackActivityMonitorProps {
+    /**
+     * The CloudFormation client
+     */
+    readonly cfn: ICloudFormationClient;
+    /**
+     * The IoHelper used for messaging
+     */
+    readonly ioHelper: IoHelper;
+    /**
+     * The stack artifact that is getting deployed
+     */
+    readonly stack: CloudFormationStackArtifact;
+    /**
+     * The name of the Stack that is getting deployed
+     */
+    readonly stackName: string;
+    /**
+     * Total number of resources to update
+     *
+     * Used to calculate a progress bar.
+     *
+     * @default - No progress reporting.
+     */
+    readonly resourcesTotal?: number;
+    /**
+     * 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;
+    /**
+     * Time to wait between fetching new activities.
+     *
+     * Must wait a reasonable amount of time between polls, since we need to consider CloudFormation API limits
+     *
+     * @default 2_000
+     */
+    readonly pollingInterval?: number;
+}
+export declare class StackActivityMonitor {
+    /**
+     * The poller used to read stack events
+     */
+    private readonly poller;
+    /**
+     * Fetch new activity every 1 second
+     * Printers can decide to update a view less frequently if desired
+     */
+    private readonly pollingInterval;
+    readonly errors: string[];
+    private monitorId?;
+    private readonly progressMonitor;
+    /**
+     * Current tick timer
+     */
+    private tickTimer?;
+    /**
+     * Set to the activity of reading the current events
+     */
+    private readPromise?;
+    private readonly ioHelper;
+    private readonly stackName;
+    private readonly stack;
+    constructor({ cfn, ioHelper, stack, stackName, resourcesTotal, changeSetCreationTime, pollingInterval, }: StackActivityMonitorProps);
+    start(): Promise<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;
+    /**
+     * Formats a stack activity into a basic string
+     */
+    private formatActivity;
+    private checkForErrors;
+}

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

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StackActivityMonitor = void 0;
+const util = require("util");
+const uuid = require("uuid");
+const stack_event_poller_1 = require("./stack-event-poller");
+const stack_progress_monitor_1 = require("./stack-progress-monitor");
+const util_1 = require("../../util");
+const private_1 = require("../io/private");
+const resource_metadata_1 = require("../resource-metadata/resource-metadata");
+class StackActivityMonitor {
+    /**
+     * The poller used to read stack events
+     */
+    poller;
+    /**
+     * Fetch new activity every 1 second
+     * Printers can decide to update a view less frequently if desired
+     */
+    pollingInterval;
+    errors = [];
+    monitorId;
+    progressMonitor;
+    /**
+     * Current tick timer
+     */
+    tickTimer;
+    /**
+     * Set to the activity of reading the current events
+     */
+    readPromise;
+    ioHelper;
+    stackName;
+    stack;
+    constructor({ cfn, ioHelper, stack, stackName, resourcesTotal, changeSetCreationTime, pollingInterval = 2_000, }) {
+        this.ioHelper = ioHelper;
+        this.stack = stack;
+        this.stackName = stackName;
+        this.progressMonitor = new stack_progress_monitor_1.StackProgressMonitor(resourcesTotal);
+        this.pollingInterval = pollingInterval;
+        this.poller = new stack_event_poller_1.StackEventPoller(cfn, {
+            stackName,
+            startTime: changeSetCreationTime?.getTime() ?? Date.now(),
+        });
+    }
+    async start() {
+        this.monitorId = uuid.v4();
+        await this.ioHelper.notify(private_1.IO.CDK_TOOLKIT_I5501.msg(`Deploying ${this.stackName}`, {
+            deployment: this.monitorId,
+            stack: this.stack,
+            stackName: this.stackName,
+            resourcesTotal: this.progressMonitor.total,
+        }));
+        this.scheduleNextTick();
+        return this;
+    }
+    async stop() {
+        const oldMonitorId = this.monitorId;
+        this.monitorId = undefined;
+        if (this.tickTimer) {
+            clearTimeout(this.tickTimer);
+        }
+        // Do a final poll for all events. This is to handle the situation where DescribeStackStatus
+        // already returned an error, but the monitor hasn't seen all the events yet and we'd end
+        // up not printing the failure reason to users.
+        await this.finalPollToEnd(oldMonitorId);
+        await this.ioHelper.notify(private_1.IO.CDK_TOOLKIT_I5503.msg(`Completed ${this.stackName}`, {
+            deployment: oldMonitorId,
+            stack: this.stack,
+            stackName: this.stackName,
+            resourcesTotal: this.progressMonitor.total,
+        }));
+    }
+    scheduleNextTick() {
+        if (!this.monitorId) {
+            return;
+        }
+        this.tickTimer = setTimeout(() => void this.tick(), this.pollingInterval);
+    }
+    async tick() {
+        if (!this.monitorId) {
+            return;
+        }
+        try {
+            this.readPromise = this.readNewEvents(this.monitorId);
+            await this.readPromise;
+            this.readPromise = undefined;
+            // We might have been stop()ped while the network call was in progress.
+            if (!this.monitorId) {
+                return;
+            }
+        }
+        catch (e) {
+            await this.ioHelper.notify(private_1.IO.CDK_TOOLKIT_E5500.msg(util.format('Error occurred while monitoring stack: %s', e), { error: e }));
+        }
+        this.scheduleNextTick();
+    }
+    findMetadataFor(logicalId) {
+        const metadata = this.stack.manifest?.metadata;
+        if (!logicalId || !metadata) {
+            return undefined;
+        }
+        return (0, resource_metadata_1.resourceMetadata)(this.stack, logicalId);
+    }
+    /**
+     * 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
+     */
+    async readNewEvents(monitorId) {
+        const pollEvents = await this.poller.poll();
+        for (const resourceEvent of pollEvents) {
+            this.progressMonitor.process(resourceEvent.event);
+            const activity = {
+                deployment: monitorId,
+                event: resourceEvent.event,
+                metadata: this.findMetadataFor(resourceEvent.event.LogicalResourceId),
+                progress: this.progressMonitor.progress,
+            };
+            this.checkForErrors(activity);
+            await this.ioHelper.notify(private_1.IO.CDK_TOOLKIT_I5502.msg(this.formatActivity(activity, true), activity));
+        }
+    }
+    /**
+     * 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.
+     */
+    async finalPollToEnd(monitorId) {
+        // If we were doing a poll, finish that first. It was started before
+        // the moment we were sure we weren't going to get any new events anymore
+        // so we need to do a new one anyway. Need to wait for this one though
+        // because our state is single-threaded.
+        if (this.readPromise) {
+            await this.readPromise;
+        }
+        await this.readNewEvents(monitorId);
+    }
+    /**
+     * Formats a stack activity into a basic string
+     */
+    formatActivity(activity, progress) {
+        const event = activity.event;
+        const metadata = activity.metadata;
+        const resourceName = metadata ? metadata.constructPath : event.LogicalResourceId || '';
+        const logicalId = resourceName !== event.LogicalResourceId ? `(${event.LogicalResourceId}) ` : '';
+        return util.format('%s | %s%s | %s | %s | %s %s%s%s', event.StackName, progress !== false ? `${activity.progress.formatted} | ` : '', new Date(event.Timestamp).toLocaleTimeString(), event.ResourceStatus || '', event.ResourceType, resourceName, logicalId, event.ResourceStatusReason ? event.ResourceStatusReason : '', metadata?.entry.trace ? `\n\t${metadata.entry.trace.join('\n\t\\_ ')}` : '');
+    }
+    checkForErrors(activity) {
+        if ((0, util_1.stackEventHasErrorMessage)(activity.event.ResourceStatus ?? '')) {
+            const isCancelled = (activity.event.ResourceStatusReason ?? '').indexOf('cancelled') > -1;
+            // Cancelled is not an interesting failure reason, nor is the stack message (stack
+            // message will just say something like "stack failed to update")
+            if (!isCancelled && activity.event.StackName !== activity.event.LogicalResourceId) {
+                this.errors.push(activity.event.ResourceStatusReason ?? '');
+            }
+        }
+    }
+}
+exports.StackActivityMonitor = StackActivityMonitor;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stack-activity-monitor.js","sourceRoot":"","sources":["stack-activity-monitor.ts"],"names":[],"mappings":"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","sourcesContent":["import * as util from 'util';\nimport type { CloudFormationStackArtifact } from '@aws-cdk/cx-api';\nimport * as uuid from 'uuid';\nimport { StackEventPoller } from './stack-event-poller';\nimport { StackProgressMonitor } from './stack-progress-monitor';\nimport type { StackActivity } from '../../payloads/stack-activity';\nimport { stackEventHasErrorMessage } from '../../util';\nimport type { ICloudFormationClient } from '../aws-auth/private';\nimport { IO, type IoHelper } from '../io/private';\nimport { resourceMetadata } from '../resource-metadata/resource-metadata';\n\nexport interface StackActivityMonitorProps {\n  /**\n   * The CloudFormation client\n   */\n  readonly cfn: ICloudFormationClient;\n\n  /**\n   * The IoHelper used for messaging\n   */\n  readonly ioHelper: IoHelper;\n\n  /**\n   * The stack artifact that is getting deployed\n   */\n  readonly stack: CloudFormationStackArtifact;\n\n  /**\n   * The name of the Stack that is getting deployed\n   */\n  readonly stackName: string;\n\n  /**\n   * Total number of resources to update\n   *\n   * Used to calculate a progress bar.\n   *\n   * @default - No progress reporting.\n   */\n  readonly resourcesTotal?: number;\n\n  /**\n   * Creation time of the change set\n   *\n   * This will be used to filter events, only showing those from after the change\n   * set creation time.\n   *\n   * It is recommended to use this, otherwise the filtering will be subject\n   * to clock drift between local and cloud machines.\n   *\n   * @default - local machine's current time\n   */\n  readonly changeSetCreationTime?: Date;\n\n  /**\n   * Time to wait between fetching new activities.\n   *\n   * Must wait a reasonable amount of time between polls, since we need to consider CloudFormation API limits\n   *\n   * @default 2_000\n   */\n  readonly pollingInterval?: number;\n}\n\nexport class StackActivityMonitor {\n  /**\n   * The poller used to read stack events\n   */\n  private readonly poller: StackEventPoller;\n\n  /**\n   * Fetch new activity every 1 second\n   * Printers can decide to update a view less frequently if desired\n   */\n  private readonly pollingInterval: number;\n\n  public readonly errors: string[] = [];\n\n  private monitorId?: string;\n\n  private readonly progressMonitor: StackProgressMonitor;\n\n  /**\n   * Current tick timer\n   */\n  private tickTimer?: ReturnType<typeof setTimeout>;\n\n  /**\n   * Set to the activity of reading the current events\n   */\n  private readPromise?: Promise<any>;\n\n  private readonly ioHelper: IoHelper;\n  private readonly stackName: string;\n  private readonly stack: CloudFormationStackArtifact;\n\n  constructor({\n    cfn,\n    ioHelper,\n    stack,\n    stackName,\n    resourcesTotal,\n    changeSetCreationTime,\n    pollingInterval = 2_000,\n  }: StackActivityMonitorProps) {\n    this.ioHelper = ioHelper;\n    this.stack = stack;\n    this.stackName = stackName;\n\n    this.progressMonitor = new StackProgressMonitor(resourcesTotal);\n    this.pollingInterval = pollingInterval;\n    this.poller = new StackEventPoller(cfn, {\n      stackName,\n      startTime: changeSetCreationTime?.getTime() ?? Date.now(),\n    });\n  }\n\n  public async start() {\n    this.monitorId = uuid.v4();\n    await this.ioHelper.notify(IO.CDK_TOOLKIT_I5501.msg(`Deploying ${this.stackName}`, {\n      deployment: this.monitorId,\n      stack: this.stack,\n      stackName: this.stackName,\n      resourcesTotal: this.progressMonitor.total,\n    }));\n    this.scheduleNextTick();\n    return this;\n  }\n\n  public async stop() {\n    const oldMonitorId = this.monitorId!;\n    this.monitorId = undefined;\n    if (this.tickTimer) {\n      clearTimeout(this.tickTimer);\n    }\n\n    // Do a final poll for all events. This is to handle the situation where DescribeStackStatus\n    // already returned an error, but the monitor hasn't seen all the events yet and we'd end\n    // up not printing the failure reason to users.\n    await this.finalPollToEnd(oldMonitorId);\n\n    await this.ioHelper.notify(IO.CDK_TOOLKIT_I5503.msg(`Completed ${this.stackName}`, {\n      deployment: oldMonitorId,\n      stack: this.stack,\n      stackName: this.stackName,\n      resourcesTotal: this.progressMonitor.total,\n    }));\n  }\n\n  private scheduleNextTick() {\n    if (!this.monitorId) {\n      return;\n    }\n\n    this.tickTimer = setTimeout(() => void this.tick(), this.pollingInterval);\n  }\n\n  private async tick() {\n    if (!this.monitorId) {\n      return;\n    }\n\n    try {\n      this.readPromise = this.readNewEvents(this.monitorId);\n      await this.readPromise;\n      this.readPromise = undefined;\n\n      // We might have been stop()ped while the network call was in progress.\n      if (!this.monitorId) {\n        return;\n      }\n    } catch (e) {\n      await this.ioHelper.notify(IO.CDK_TOOLKIT_E5500.msg(\n        util.format('Error occurred while monitoring stack: %s', e),\n        { error: e as any },\n      ));\n    }\n    this.scheduleNextTick();\n  }\n\n  private findMetadataFor(logicalId: string | undefined) {\n    const metadata = this.stack.manifest?.metadata;\n    if (!logicalId || !metadata) {\n      return undefined;\n    }\n    return resourceMetadata(this.stack, logicalId);\n  }\n\n  /**\n   * Reads all new events from the stack history\n   *\n   * The events are returned in reverse chronological order; we continue to the next page if we\n   * see a next page and the last event in the page is new to us (and within the time window).\n   * haven't seen the final event\n   */\n  private async readNewEvents(monitorId: string): Promise<void> {\n    const pollEvents = await this.poller.poll();\n\n    for (const resourceEvent of pollEvents) {\n      this.progressMonitor.process(resourceEvent.event);\n\n      const activity: StackActivity = {\n        deployment: monitorId,\n        event: resourceEvent.event,\n        metadata: this.findMetadataFor(resourceEvent.event.LogicalResourceId),\n        progress: this.progressMonitor.progress,\n      };\n\n      this.checkForErrors(activity);\n      await this.ioHelper.notify(IO.CDK_TOOLKIT_I5502.msg(this.formatActivity(activity, true), activity));\n    }\n  }\n\n  /**\n   * Perform a final poll to the end and flush out all events to the printer\n   *\n   * Finish any poll currently in progress, then do a final one until we've\n   * reached the last page.\n   */\n  private async finalPollToEnd(monitorId: string) {\n    // If we were doing a poll, finish that first. It was started before\n    // the moment we were sure we weren't going to get any new events anymore\n    // so we need to do a new one anyway. Need to wait for this one though\n    // because our state is single-threaded.\n    if (this.readPromise) {\n      await this.readPromise;\n    }\n\n    await this.readNewEvents(monitorId);\n  }\n\n  /**\n   * Formats a stack activity into a basic string\n   */\n  private formatActivity(activity: StackActivity, progress: boolean): string {\n    const event = activity.event;\n    const metadata = activity.metadata;\n\n    const resourceName = metadata ? metadata.constructPath : event.LogicalResourceId || '';\n    const logicalId = resourceName !== event.LogicalResourceId ? `(${event.LogicalResourceId}) ` : '';\n\n    return util.format(\n      '%s | %s%s | %s | %s | %s %s%s%s',\n      event.StackName,\n      progress !== false ? `${activity.progress.formatted} | ` : '',\n      new Date(event.Timestamp!).toLocaleTimeString(),\n      event.ResourceStatus || '',\n      event.ResourceType,\n      resourceName,\n      logicalId,\n      event.ResourceStatusReason ? event.ResourceStatusReason : '',\n      metadata?.entry.trace ? `\\n\\t${metadata.entry.trace.join('\\n\\t\\\\_ ')}` : '',\n    );\n  }\n\n  private checkForErrors(activity: StackActivity) {\n    if (stackEventHasErrorMessage(activity.event.ResourceStatus ?? '')) {\n      const isCancelled = (activity.event.ResourceStatusReason ?? '').indexOf('cancelled') > -1;\n\n      // Cancelled is not an interesting failure reason, nor is the stack message (stack\n      // message will just say something like \"stack failed to update\")\n      if (!isCancelled && activity.event.StackName !== activity.event.LogicalResourceId) {\n        this.errors.push(activity.event.ResourceStatusReason ?? '');\n      }\n    }\n  }\n}\n"]}

package/lib/api/stack-events/stack-event-poller.d.ts

@@ -0,0 +1,69 @@
+import type { StackEvent } from '@aws-sdk/client-cloudformation';
+import type { ICloudFormationClient } from '../aws-auth/private';
+export interface StackEventPollerProps {
+    /**
+     * The stack to poll
+     */
+    readonly stackName: string;
+    /**
+     * IDs of parent stacks of this resource, in case of resources in nested stacks
+     */
+    readonly parentStackLogicalIds?: string[];
+    /**
+     * Timestamp for the oldest event we're interested in
+     *
+     * @default - Read all events
+     */
+    readonly startTime?: number;
+    /**
+     * Stop reading when we see the stack entering this status
+     *
+     * Should be something like `CREATE_IN_PROGRESS`, `UPDATE_IN_PROGRESS`,
+     * `DELETE_IN_PROGRESS, `ROLLBACK_IN_PROGRESS`.
+     *
+     * @default - Read all events
+     */
+    readonly stackStatuses?: string[];
+}
+export interface ResourceEvent {
+    /**
+     * The Stack Event as received from CloudFormation
+     */
+    readonly event: StackEvent;
+    /**
+     * IDs of parent stacks of the resource, in case of resources in nested stacks
+     */
+    readonly parentStackLogicalIds: string[];
+    /**
+     * Whether this event regards the root stack
+     *
+     * @default false
+     */
+    readonly isStackEvent?: boolean;
+}
+export declare class StackEventPoller {
+    private readonly cfn;
+    private readonly props;
+    readonly events: ResourceEvent[];
+    complete: boolean;
+    private readonly eventIds;
+    private readonly nestedStackPollers;
+    constructor(cfn: ICloudFormationClient, props: StackEventPollerProps);
+    /**
+     * From all accumulated events, return only the errors
+     */
+    get resourceErrors(): ResourceEvent[];
+    /**
+     * Poll for new stack events
+     *
+     * Will not return events older than events indicated by the constructor filters.
+     *
+     * Recurses into nested stacks, and returns events old-to-new.
+     */
+    poll(): Promise<ResourceEvent[]>;
+    private doPoll;
+    /**
+     * On the CREATE_IN_PROGRESS, UPDATE_IN_PROGRESS, DELETE_IN_PROGRESS event of a nested stack, poll the nested stack updates
+     */
+    private trackNestedStack;
+}

package/lib/api/stack-events/stack-event-poller.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StackEventPoller = void 0;
+const util_1 = require("../../util");
+class StackEventPoller {
+    cfn;
+    props;
+    events = [];
+    complete = false;
+    eventIds = new Set();
+    nestedStackPollers = {};
+    constructor(cfn, props) {
+        this.cfn = cfn;
+        this.props = props;
+    }
+    /**
+     * From all accumulated events, return only the errors
+     */
+    get resourceErrors() {
+        return this.events.filter((e) => e.event.ResourceStatus?.endsWith('_FAILED') && !e.isStackEvent);
+    }
+    /**
+     * Poll for new stack events
+     *
+     * Will not return events older than events indicated by the constructor filters.
+     *
+     * Recurses into nested stacks, and returns events old-to-new.
+     */
+    async poll() {
+        const events = await this.doPoll();
+        // Also poll all nested stacks we're currently tracking
+        for (const [logicalId, poller] of Object.entries(this.nestedStackPollers)) {
+            events.push(...(await poller.poll()));
+            if (poller.complete) {
+                delete this.nestedStackPollers[logicalId];
+            }
+        }
+        // Return what we have so far
+        events.sort((a, b) => a.event.Timestamp.valueOf() - b.event.Timestamp.valueOf());
+        this.events.push(...events);
+        return events;
+    }
+    async doPoll() {
+        const events = [];
+        try {
+            let nextToken;
+            let finished = false;
+            while (!finished) {
+                const page = await this.cfn.describeStackEvents({ StackName: this.props.stackName, NextToken: nextToken });
+                for (const event of page?.StackEvents ?? []) {
+                    // Event from before we were interested in 'em
+                    if (this.props.startTime !== undefined && event.Timestamp.valueOf() < this.props.startTime) {
+                        return events;
+                    }
+                    // Already seen this one
+                    if (this.eventIds.has(event.EventId)) {
+                        return events;
+                    }
+                    this.eventIds.add(event.EventId);
+                    // The events for the stack itself are also included next to events about resources; we can test for them in this way.
+                    const isParentStackEvent = event.PhysicalResourceId === event.StackId;
+                    if (isParentStackEvent && this.props.stackStatuses?.includes(event.ResourceStatus ?? '')) {
+                        return events;
+                    }
+                    // Fresh event
+                    const resEvent = {
+                        event: event,
+                        parentStackLogicalIds: this.props.parentStackLogicalIds ?? [],
+                        isStackEvent: isParentStackEvent,
+                    };
+                    events.push(resEvent);
+                    if (!isParentStackEvent &&
+                        event.ResourceType === 'AWS::CloudFormation::Stack' &&
+                        isStackBeginOperationState(event.ResourceStatus)) {
+                        // If the event is not for `this` stack and has a physical resource Id, recursively call for events in the nested stack
+                        this.trackNestedStack(event, [...(this.props.parentStackLogicalIds ?? []), event.LogicalResourceId ?? '']);
+                    }
+                    if (isParentStackEvent && isStackTerminalState(event.ResourceStatus)) {
+                        this.complete = true;
+                    }
+                }
+                nextToken = page?.NextToken;
+                if (nextToken === undefined) {
+                    finished = true;
+                }
+            }
+        }
+        catch (e) {
+            if (!(e.name === 'ValidationError' && (0, util_1.formatErrorMessage)(e) === `Stack [${this.props.stackName}] does not exist`)) {
+                throw e;
+            }
+        }
+        return events;
+    }
+    /**
+     * On the CREATE_IN_PROGRESS, UPDATE_IN_PROGRESS, DELETE_IN_PROGRESS event of a nested stack, poll the nested stack updates
+     */
+    trackNestedStack(event, parentStackLogicalIds) {
+        const logicalId = event.LogicalResourceId;
+        const physicalResourceId = event.PhysicalResourceId;
+        // The CREATE_IN_PROGRESS event for a Nested Stack is emitted twice; first without a PhysicalResourceId
+        // and then with. Ignore this event if we don't have that property yet.
+        //
+        // (At this point, I also don't trust that logicalId is always going to be there so validate that as well)
+        if (!logicalId || !physicalResourceId) {
+            return;
+        }
+        if (!this.nestedStackPollers[logicalId]) {
+            this.nestedStackPollers[logicalId] = new StackEventPoller(this.cfn, {
+                stackName: physicalResourceId,
+                parentStackLogicalIds: parentStackLogicalIds,
+                startTime: event.Timestamp.valueOf(),
+            });
+        }
+    }
+}
+exports.StackEventPoller = StackEventPoller;
+function isStackBeginOperationState(state) {
+    return [
+        'CREATE_IN_PROGRESS',
+        'UPDATE_IN_PROGRESS',
+        'DELETE_IN_PROGRESS',
+        'UPDATE_ROLLBACK_IN_PROGRESS',
+        'ROLLBACK_IN_PROGRESS',
+    ].includes(state ?? '');
+}
+function isStackTerminalState(state) {
+    return !(state ?? '').endsWith('_IN_PROGRESS');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stack-event-poller.js","sourceRoot":"","sources":["stack-event-poller.ts"],"names":[],"mappings":"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","sourcesContent":["import type { StackEvent } from '@aws-sdk/client-cloudformation';\nimport { formatErrorMessage } from '../../util';\nimport type { ICloudFormationClient } from '../aws-auth/private';\n\nexport interface StackEventPollerProps {\n  /**\n   * The stack to poll\n   */\n  readonly stackName: string;\n\n  /**\n   * IDs of parent stacks of this resource, in case of resources in nested stacks\n   */\n  readonly parentStackLogicalIds?: string[];\n\n  /**\n   * Timestamp for the oldest event we're interested in\n   *\n   * @default - Read all events\n   */\n  readonly startTime?: number;\n\n  /**\n   * Stop reading when we see the stack entering this status\n   *\n   * Should be something like `CREATE_IN_PROGRESS`, `UPDATE_IN_PROGRESS`,\n   * `DELETE_IN_PROGRESS, `ROLLBACK_IN_PROGRESS`.\n   *\n   * @default - Read all events\n   */\n  readonly stackStatuses?: string[];\n}\n\nexport interface ResourceEvent {\n  /**\n   * The Stack Event as received from CloudFormation\n   */\n  readonly event: StackEvent;\n\n  /**\n   * IDs of parent stacks of the resource, in case of resources in nested stacks\n   */\n  readonly parentStackLogicalIds: string[];\n\n  /**\n   * Whether this event regards the root stack\n   *\n   * @default false\n   */\n  readonly isStackEvent?: boolean;\n}\n\nexport class StackEventPoller {\n  public readonly events: ResourceEvent[] = [];\n  public complete: boolean = false;\n\n  private readonly eventIds = new Set<string>();\n  private readonly nestedStackPollers: Record<string, StackEventPoller> = {};\n\n  constructor(\n    private readonly cfn: ICloudFormationClient,\n    private readonly props: StackEventPollerProps,\n  ) {\n  }\n\n  /**\n   * From all accumulated events, return only the errors\n   */\n  public get resourceErrors(): ResourceEvent[] {\n    return this.events.filter((e) => e.event.ResourceStatus?.endsWith('_FAILED') && !e.isStackEvent);\n  }\n\n  /**\n   * Poll for new stack events\n   *\n   * Will not return events older than events indicated by the constructor filters.\n   *\n   * Recurses into nested stacks, and returns events old-to-new.\n   */\n  public async poll(): Promise<ResourceEvent[]> {\n    const events: ResourceEvent[] = await this.doPoll();\n\n    // Also poll all nested stacks we're currently tracking\n    for (const [logicalId, poller] of Object.entries(this.nestedStackPollers)) {\n      events.push(...(await poller.poll()));\n      if (poller.complete) {\n        delete this.nestedStackPollers[logicalId];\n      }\n    }\n\n    // Return what we have so far\n    events.sort((a, b) => a.event.Timestamp!.valueOf() - b.event.Timestamp!.valueOf());\n    this.events.push(...events);\n    return events;\n  }\n\n  private async doPoll(): Promise<ResourceEvent[]> {\n    const events: ResourceEvent[] = [];\n    try {\n      let nextToken: string | undefined;\n      let finished = false;\n\n      while (!finished) {\n        const page = await this.cfn.describeStackEvents({ StackName: this.props.stackName, NextToken: nextToken });\n        for (const event of page?.StackEvents ?? []) {\n          // Event from before we were interested in 'em\n          if (this.props.startTime !== undefined && event.Timestamp!.valueOf() < this.props.startTime) {\n            return events;\n          }\n\n          // Already seen this one\n          if (this.eventIds.has(event.EventId!)) {\n            return events;\n          }\n          this.eventIds.add(event.EventId!);\n\n          // The events for the stack itself are also included next to events about resources; we can test for them in this way.\n          const isParentStackEvent = event.PhysicalResourceId === event.StackId;\n\n          if (isParentStackEvent && this.props.stackStatuses?.includes(event.ResourceStatus ?? '')) {\n            return events;\n          }\n\n          // Fresh event\n          const resEvent: ResourceEvent = {\n            event: event,\n            parentStackLogicalIds: this.props.parentStackLogicalIds ?? [],\n            isStackEvent: isParentStackEvent,\n          };\n          events.push(resEvent);\n\n          if (\n            !isParentStackEvent &&\n              event.ResourceType === 'AWS::CloudFormation::Stack' &&\n              isStackBeginOperationState(event.ResourceStatus)\n          ) {\n            // If the event is not for `this` stack and has a physical resource Id, recursively call for events in the nested stack\n            this.trackNestedStack(event, [...(this.props.parentStackLogicalIds ?? []), event.LogicalResourceId ?? '']);\n          }\n\n          if (isParentStackEvent && isStackTerminalState(event.ResourceStatus)) {\n            this.complete = true;\n          }\n        }\n\n        nextToken = page?.NextToken;\n        if (nextToken === undefined) {\n          finished = true;\n        }\n      }\n    } catch (e: any) {\n      if (!(e.name === 'ValidationError' && formatErrorMessage(e) === `Stack [${this.props.stackName}] does not exist`)) {\n        throw e;\n      }\n    }\n\n    return events;\n  }\n\n  /**\n   * On the CREATE_IN_PROGRESS, UPDATE_IN_PROGRESS, DELETE_IN_PROGRESS event of a nested stack, poll the nested stack updates\n   */\n  private trackNestedStack(event: StackEvent, parentStackLogicalIds: string[]) {\n    const logicalId = event.LogicalResourceId;\n    const physicalResourceId = event.PhysicalResourceId;\n\n    // The CREATE_IN_PROGRESS event for a Nested Stack is emitted twice; first without a PhysicalResourceId\n    // and then with. Ignore this event if we don't have that property yet.\n    //\n    // (At this point, I also don't trust that logicalId is always going to be there so validate that as well)\n    if (!logicalId || !physicalResourceId) {\n      return;\n    }\n\n    if (!this.nestedStackPollers[logicalId]) {\n      this.nestedStackPollers[logicalId] = new StackEventPoller(this.cfn, {\n        stackName: physicalResourceId,\n        parentStackLogicalIds: parentStackLogicalIds,\n        startTime: event.Timestamp!.valueOf(),\n      });\n    }\n  }\n}\n\nfunction isStackBeginOperationState(state: string | undefined) {\n  return [\n    'CREATE_IN_PROGRESS',\n    'UPDATE_IN_PROGRESS',\n    'DELETE_IN_PROGRESS',\n    'UPDATE_ROLLBACK_IN_PROGRESS',\n    'ROLLBACK_IN_PROGRESS',\n  ].includes(state ?? '');\n}\n\nfunction isStackTerminalState(state: string | undefined) {\n  return !(state ?? '').endsWith('_IN_PROGRESS');\n}\n"]}

package/lib/api/stack-events/stack-progress-monitor.d.ts

@@ -0,0 +1,48 @@
+import type { StackEvent } from '@aws-sdk/client-cloudformation';
+import type { StackProgress } from '../../payloads/progress';
+/**
+ * Monitors stack progress.s
+ */
+export declare 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
+     */
+    private resourcesPrevCompleteState;
+    /**
+     * Count of resources that have reported a _COMPLETE status
+     */
+    private resourcesDone;
+    /**
+     * How many digits we need to represent the total count (for lining up the status reporting)
+     */
+    private readonly resourceDigits;
+    /**
+     * Number of expected resources in the monitor.
+     */
+    private readonly resourcesTotal?;
+    constructor(resourcesTotal?: number);
+    /**
+     * Report the stack progress
+     */
+    get progress(): StackProgress;
+    /**
+     * The total number of progress monitored resources.
+     */
+    get total(): number | undefined;
+    /**
+     * The number of completed resources.
+     */
+    get completed(): number;
+    /**
+     * Report the current progress as a [34/42] string, or just [34] if the total is unknown
+     */
+    get formatted(): string;
+    /**
+     * Process as stack event and update the progress state.
+     */
+    process(event: StackEvent): void;
+}