takomo 4.6.1 → 5.0.0-alpha.2

package/bin/tkm

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 var semver = require("semver")
-var requiredVersion = "14.17.1"
+var requiredVersion = "16.17.0"
 if (!semver.satisfies(process.version, ">=" + requiredVersion)) {
     console.log("ERROR")
     console.log("-----")
@@ -17,4 +17,5 @@ if (!semver.satisfies(process.version, ">=" + requiredVersion)) {
     process.exit(1)
 }
 
-require('../dist/index.js');
+const { run } = require('../dist/index.js')
+run()

package/dist/index.d.ts

@@ -1 +1,7 @@
 import "source-map-support/register";
+export { Stack, Resolver, ResolverProvider, Hook, HookProvider, HookOutput, HookInput, ResolverInput, ResolverProviderSchemaProps, HookOutputObject, StacksContext, HookOperation, HookStage, HookStatus, StackOperationVariables, HookOutputValues, } from "./takomo-stacks-model";
+export { CredentialManager } from "./takomo-aws-clients";
+export { CommandContext, OutputFormat, TakomoProjectConfig, Variables, ContextVars, EnvVars, Vars, TakomoProjectDeploymentTargetsConfig, DeploymentTargetRepositoryConfig, } from "./takomo-core";
+export { CallerIdentity, CloudFormationStack, BaseCloudFormationStack, StackDriftInformation, StackDriftStatus, StackParameter, StackCapability, StackOutput, StackStatus, Tag, } from "./takomo-aws-model";
+export { TkmLogger, LogLevel, TemplateEngine } from "./takomo-util";
+export { run } from "./takomo-cli";

package/dist/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const cli_1 = require("@takomo/cli");
+exports.run = void 0;
 require("source-map-support/register");
-(0, cli_1.run)();
+var takomo_cli_1 = require("./takomo-cli");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return takomo_cli_1.run; } });
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;AAAA,qCAAiC;AACjC,uCAAoC;AACpC,IAAA,SAAG,GAAE,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,uCAAoC;AA4CpC,2CAAkC;AAAzB,iGAAA,GAAG,OAAA"}

package/dist/takomo-aws-clients/aws-client-provider.d.ts

@@ -0,0 +1,30 @@
+import { Region } from "../takomo-aws-model";
+import { TkmLogger } from "../takomo-util";
+import { CloudFormationClient } from "./cloudformation/client";
+import { CloudTrailClient } from "./cloudtrail/client";
+import { ApiCallProps, AwsClientProps, CloudFormationClientProps } from "./common/client";
+import { OrganizationsClient } from "./organizations/client";
+import { S3Client } from "./s3/client";
+import { StsClient } from "./sts/client";
+export interface AwsClientProvider {
+    readonly createCloudFormationClient: (props: CloudFormationClientProps) => Promise<CloudFormationClient>;
+    readonly createCloudTrailClient: (props: AwsClientProps) => Promise<CloudTrailClient>;
+    readonly createS3Client: (props: AwsClientProps) => Promise<S3Client>;
+    readonly createStsClient: (props: AwsClientProps) => Promise<StsClient>;
+    readonly createOrganizationsClient: (props: AwsClientProps) => Promise<OrganizationsClient>;
+}
+/**
+ * @hidden
+ */
+export interface InternalAwsClientProvider extends AwsClientProvider {
+    readonly getApiCalls: () => ReadonlyArray<ApiCallProps>;
+    readonly getRegions: () => ReadonlyArray<Region>;
+}
+interface AwsClientProviderProps {
+    readonly logger: TkmLogger;
+}
+/**
+ * @hidden
+ */
+export declare const createAwsClientProvider: ({ logger, }: AwsClientProviderProps) => InternalAwsClientProvider;
+export {};

package/dist/takomo-aws-clients/aws-client-provider.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAwsClientProvider = void 0;
+const cockatiel_1 = require("cockatiel");
+const takomo_util_1 = require("../takomo-util");
+const client_1 = require("./cloudformation/client");
+const client_2 = require("./cloudtrail/client");
+const request_listener_1 = require("./common/request-listener");
+const client_3 = require("./organizations/client");
+const client_4 = require("./s3/client");
+const client_5 = require("./sts/client");
+const makeIdentityRegionHash = (region, identity) => (0, takomo_util_1.checksum)([region, identity.accountId].join(":"));
+const createDescribeEventsBulkhead = () => {
+    const limit = 2;
+    const queue = 1000;
+    return cockatiel_1.Policy.bulkhead(limit, queue);
+};
+const createGetTemplateSummaryScheduler = (logger) => (0, takomo_util_1.createScheduler)({
+    logger,
+    id: "GetTemplateSummary",
+    intervalCap: 2,
+    concurrency: 5,
+    intervalInMillis: 200,
+});
+const createValidateTemplateBulkhead = () => {
+    const limit = 4;
+    const queue = 1000;
+    return cockatiel_1.Policy.bulkhead(limit, queue);
+};
+/**
+ * @hidden
+ */
+const createAwsClientProvider = ({ logger, }) => {
+    const apiCalls = new Array();
+    const regions = new Set();
+    const concurrencyControls = new Map();
+    const getConcurrencyControls = (key) => {
+        if (concurrencyControls.has(key)) {
+            return concurrencyControls.get(key);
+        }
+        const controls = {
+            describeEventsBulkhead: createDescribeEventsBulkhead(),
+            getTemplateSummaryScheduler: createGetTemplateSummaryScheduler(logger),
+            validateTemplateBulkhead: createValidateTemplateBulkhead(),
+        };
+        concurrencyControls.set(key, controls);
+        return controls;
+    };
+    const listener = {
+        onApiCall: (props) => {
+            apiCalls.push(props);
+        },
+    };
+    return {
+        getRegions: () => Array.from(regions),
+        getApiCalls: () => apiCalls.slice(),
+        createCloudFormationClient: async (props) => {
+            const hash = makeIdentityRegionHash(props.region, props.identity);
+            const controls = getConcurrencyControls(hash);
+            const client = (0, client_1.createCloudFormationClient)({
+                ...props,
+                ...controls,
+                waitStackDeployToCompletePollInterval: 2000,
+                waitStackDeleteToCompletePollInterval: 2000,
+                waitStackRollbackToCompletePollInterval: 2000,
+                middleware: (0, request_listener_1.createApiRequestListenerPlugin)(logger, props.id, listener),
+            });
+            regions.add(props.region);
+            return client;
+        },
+        createCloudTrailClient: async (props) => {
+            const client = (0, client_2.createCloudTrailClient)({
+                ...props,
+                middleware: (0, request_listener_1.createApiRequestListenerPlugin)(logger, props.id, listener),
+            });
+            regions.add(props.region);
+            return client;
+        },
+        createS3Client: async (props) => {
+            const client = (0, client_4.createS3Client)({
+                ...props,
+                middleware: (0, request_listener_1.createApiRequestListenerPlugin)(logger, props.id, listener),
+            });
+            regions.add(props.region);
+            return client;
+        },
+        createStsClient: async (props) => {
+            const client = (0, client_5.createStsClient)({
+                ...props,
+                middleware: (0, request_listener_1.createApiRequestListenerPlugin)(logger, props.id, listener),
+            });
+            regions.add(props.region);
+            return client;
+        },
+        createOrganizationsClient: async (props) => {
+            const client = (0, client_3.createOrganizationsClient)({
+                ...props,
+                middleware: (0, request_listener_1.createApiRequestListenerPlugin)(logger, props.id, listener),
+            });
+            regions.add(props.region);
+            return client;
+        },
+    };
+};
+exports.createAwsClientProvider = createAwsClientProvider;
+//# sourceMappingURL=aws-client-provider.js.map

package/dist/takomo-aws-clients/aws-client-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aws-client-provider.js","sourceRoot":"","sources":["../../src/takomo-aws-clients/aws-client-provider.ts"],"names":[],"mappings":"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"}

package/dist/takomo-aws-clients/cloudformation/client.d.ts

@@ -0,0 +1,123 @@
+import { CloudFormation, CreateChangeSetInput, CreateStackInput, DeleteStackInput, GetTemplateSummaryInput, UpdateStackInput, ValidateTemplateInput } from "@aws-sdk/client-cloudformation";
+import { IPolicy } from "cockatiel";
+import { ChangeSet, ChangeSetId, ClientRequestToken, CloudFormationStack, CloudFormationStackSummary, DetailedCloudFormationStack, DetailedCloudFormationStackSummary, EventId, ResourceStatus, StackDriftDetectionId, StackDriftDetectionStatusOutput, StackEvent, StackId, StackName, StackPolicyBody, StackStatus, TemplateSummary } from "../../takomo-aws-model";
+import { Scheduler } from "../../takomo-util";
+import { InternalAwsClientProps } from "../common/client";
+export interface CloudFormationClient {
+    readonly validateTemplate: (input: ValidateTemplateInput) => Promise<boolean>;
+    readonly describeStack: (stackName: string) => Promise<CloudFormationStack | undefined>;
+    readonly listNotDeletedStacks: (stackNames?: ReadonlyArray<StackName>) => Promise<Map<StackName, DetailedCloudFormationStackSummary>>;
+    readonly getNotDeletedStack: (stackName: StackName) => Promise<DetailedCloudFormationStackSummary>;
+    readonly enrichStack: (stack: CloudFormationStack) => Promise<DetailedCloudFormationStack>;
+    readonly enrichStackSummary: (stack: CloudFormationStackSummary) => Promise<DetailedCloudFormationStack>;
+    readonly getTemplateSummary: (input: GetTemplateSummaryInput) => Promise<TemplateSummary>;
+    readonly getCurrentTemplate: (stackName: string) => Promise<string>;
+    readonly initiateStackDeletion: (input: DeleteStackInput) => Promise<boolean>;
+    readonly createChangeSet: (params: CreateChangeSetInput) => Promise<ChangeSetId>;
+    readonly deleteChangeSet: (stackName: string, changeSetName: string) => Promise<boolean>;
+    readonly describeChangeSet: (stackName: string, changeSetName: string) => Promise<ChangeSet>;
+    readonly waitUntilChangeSetIsReady: (stackName: string, changeSetName: string) => Promise<ChangeSet | undefined>;
+    readonly describeStackEvents: (stackName: string) => Promise<ReadonlyArray<StackEvent>>;
+    readonly cancelStackUpdate: (stackName: string) => Promise<string>;
+    readonly continueUpdateRollback: (stackNameOrId: StackName | StackId) => Promise<ClientRequestToken>;
+    readonly createStack: (params: CreateStackInput) => Promise<StackId>;
+    readonly updateStack: (params: UpdateStackInput) => Promise<boolean>;
+    readonly updateTerminationProtection: (stackName: string, enable: boolean) => Promise<boolean>;
+    readonly getNativeClient: () => Promise<CloudFormation>;
+    readonly waitStackRollbackToComplete: (props: WaitStackRollbackToCompleteProps) => Promise<StackRollbackCompleteResponse>;
+    readonly waitStackDeployToComplete: (props: WaitStackDeployToCompleteProps) => Promise<WaitStackDeployToCompleteResponse>;
+    readonly waitStackDeleteToComplete: (props: WaitStackDeleteToCompleteProps) => Promise<WaitStackDeleteToCompleteResponse>;
+    readonly getStackPolicy: (stackName: string) => Promise<StackPolicyBody | undefined>;
+    readonly detectDrift: (stackName: StackName) => Promise<StackDriftDetectionId>;
+    readonly describeStackDriftDetectionStatus: (id: StackDriftDetectionId) => Promise<StackDriftDetectionStatusOutput>;
+    readonly waitDriftDetectionToComplete: (id: StackDriftDetectionId) => Promise<StackDriftDetectionStatusOutput>;
+}
+interface CloudFormationClientProps extends InternalAwsClientProps {
+    readonly describeEventsBulkhead: IPolicy;
+    readonly getTemplateSummaryScheduler: Scheduler;
+    readonly validateTemplateBulkhead: IPolicy;
+    readonly waitStackDeployToCompletePollInterval: number;
+    readonly waitStackDeleteToCompletePollInterval: number;
+    readonly waitStackRollbackToCompletePollInterval: number;
+}
+/**
+ * @hidden
+ */
+export declare const createCloudFormationClient: (props: CloudFormationClientProps) => CloudFormationClient;
+/**
+ * @hidden
+ */
+export interface TimeoutConfig {
+    readonly startTime: number;
+    readonly timeout: number;
+    readonly timeoutOccurred: boolean;
+}
+/**
+ * @hidden
+ */
+export interface ChangeSetCompletionResponse {
+    readonly events: ReadonlyArray<StackEvent>;
+    readonly stackStatus: StackStatus;
+    readonly timeoutConfig: TimeoutConfig;
+}
+/**
+ * @hidden
+ */
+export interface WaitStackDeployToCompleteResponse {
+    readonly events: ReadonlyArray<StackEvent>;
+    readonly stackStatus: ResourceStatus;
+    readonly timeoutConfig: TimeoutConfig;
+}
+/**
+ * @hidden
+ */
+export interface WaitStackDeployToCompleteProps {
+    readonly stackId: StackId;
+    readonly clientToken: ClientRequestToken;
+    readonly eventListener: (event: StackEvent) => void;
+    readonly timeoutConfig: TimeoutConfig;
+    readonly allEvents?: ReadonlyArray<StackEvent>;
+    readonly latestEventId?: EventId;
+}
+/**
+ * @hidden
+ */
+export interface WaitStackDeleteToCompleteResponse {
+    readonly events: ReadonlyArray<StackEvent>;
+    readonly stackStatus: ResourceStatus;
+}
+/**
+ * @hidden
+ */
+export interface WaitStackDeleteToCompleteProps {
+    readonly stackId: StackId;
+    readonly clientToken: ClientRequestToken;
+    readonly eventListener: (event: StackEvent) => void;
+    readonly allEvents?: ReadonlyArray<StackEvent>;
+    readonly latestEventId?: EventId;
+}
+/**
+ * @hidden
+ */
+export interface StackDeleteCompletionResponse {
+    readonly events: ReadonlyArray<StackEvent>;
+    readonly stackStatus: StackStatus;
+}
+/**
+ * @hidden
+ */
+export interface WaitStackRollbackToCompleteProps {
+    readonly stackId: StackId;
+    readonly clientToken: ClientRequestToken;
+    readonly eventListener: (event: StackEvent) => void;
+    readonly allEvents?: ReadonlyArray<StackEvent>;
+    readonly latestEventId?: EventId;
+}
+/**
+ * @hidden
+ */
+export interface StackRollbackCompleteResponse {
+    readonly events: ReadonlyArray<StackEvent>;
+    readonly stackStatus: StackStatus;
+}
+export {};

package/dist/takomo-aws-clients/cloudformation/client.js

@@ -0,0 +1,347 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCloudFormationClient = void 0;
+const client_cloudformation_1 = require("@aws-sdk/client-cloudformation");
+const lodash_takerightwhile_1 = __importDefault(require("lodash.takerightwhile"));
+const ramda_1 = __importDefault(require("ramda"));
+const takomo_aws_model_1 = require("../../takomo-aws-model");
+const takomo_util_1 = require("../../takomo-util");
+const client_1 = require("../common/client");
+const request_handler_1 = require("../common/request-handler");
+const retry_1 = require("../common/retry");
+const convert_1 = require("./convert");
+const describe_change_set_rule_1 = require("./rules/describe-change-set-rule");
+const findTerminalEvent = (stackId, events) => events.find(({ resourceType, physicalResourceId, resourceStatus }) => resourceType === "AWS::CloudFormation::Stack" &&
+    physicalResourceId === stackId &&
+    (0, takomo_aws_model_1.isTerminalResourceStatus)(resourceStatus));
+/**
+ * @hidden
+ */
+const createCloudFormationClient = (props) => {
+    const { logger, middleware, describeEventsBulkhead, getTemplateSummaryScheduler, validateTemplateBulkhead, waitStackDeployToCompletePollInterval, waitStackDeleteToCompletePollInterval, waitStackRollbackToCompletePollInterval, } = props;
+    const client = new client_cloudformation_1.CloudFormation({
+        region: props.region,
+        credentials: props.credentialProvider,
+        retryStrategy: (0, retry_1.customRetryStrategy)(),
+        requestHandler: (0, request_handler_1.customRequestHandler)(25),
+    });
+    client.middlewareStack.use(middleware);
+    const getStackPolicy = (stackName) => client
+        .getStackPolicy({ StackName: stackName })
+        .then((r) => r.StackPolicyBody);
+    const detectDrift = (stackName) => client
+        .detectStackDrift({ StackName: stackName })
+        .then((r) => r.StackDriftDetectionId);
+    const describeStackDriftDetectionStatus = (id) => client
+        .describeStackDriftDetectionStatus({ StackDriftDetectionId: id })
+        .then(convert_1.convertStackDriftDetectionStatus);
+    const waitDriftDetectionToComplete = async (id) => {
+        const status = await describeStackDriftDetectionStatus(id);
+        switch (status.detectionStatus) {
+            case "DETECTION_COMPLETE":
+            case "DETECTION_FAILED":
+                return status;
+            default:
+                await (0, takomo_util_1.sleep)(5000);
+                return waitDriftDetectionToComplete(id);
+        }
+    };
+    const validateTemplate = (input) => (0, client_1.withClientBulkhead)(client, validateTemplateBulkhead, (c) => c.validateTemplate(input).then(() => true));
+    const describeStack = (stackName) => client
+        .describeStacks({ StackName: stackName })
+        .then(convert_1.convertStack)
+        .catch((e) => {
+        if (e.Code === "ValidationError") {
+            if (e.message === `Stack with id ${stackName} does not exist`) {
+                return undefined;
+            }
+        }
+        throw e;
+    });
+    const listNotDeletedStacks = (stackNames) => {
+        const collectedNames = new Set();
+        return (0, client_1.pagedOperationV2)({
+            operation: (params) => client.listStacks(params),
+            params: { StackStatusFilter: takomo_aws_model_1.ACTIVE_STACK_STATUSES.slice() },
+            extractor: convert_1.convertStackSummaries,
+            filter: (s) => !stackNames || stackNames.includes(s.name),
+            onPage: (items) => {
+                if (!stackNames) {
+                    return false;
+                }
+                items.forEach((item) => collectedNames.add(item.name));
+                return stackNames.every((s) => collectedNames.has(s));
+            },
+        }).then((stacks) => new Map((0, takomo_util_1.arrayToMap)(stacks, (s) => s.name)));
+    };
+    const getNotDeletedStack = async (stackName) => {
+        const stacks = await listNotDeletedStacks([stackName]);
+        const stack = stacks.get(stackName);
+        if (!stack) {
+            throw new Error(`Stack not found with name: '${stackName}'`);
+        }
+        return stack;
+    };
+    const enrichStack = async (stack) => {
+        const [summary, templateBody, stackPolicyBody] = await Promise.all([
+            getTemplateSummary({
+                StackName: stack.name,
+            }),
+            getCurrentTemplate(stack.name),
+            getStackPolicy(stack.name),
+        ]);
+        const parameterMap = new Map(stack.parameters.map((p) => [p.key, p]));
+        const parameters = summary.parameters.map((declaration) => {
+            const stackParam = parameterMap.get(declaration.key);
+            if (!stackParam) {
+                throw new Error(`Parameter '${declaration.key}' not found`);
+            }
+            return {
+                ...stackParam,
+                ...declaration,
+            };
+        });
+        return {
+            ...stack,
+            templateBody,
+            stackPolicyBody,
+            parameters,
+        };
+    };
+    const enrichStackSummary = async (stackSummary) => {
+        const [summary, templateBody, stackPolicyBody, stack] = await Promise.all([
+            getTemplateSummary({
+                StackName: stackSummary.name,
+            }),
+            getCurrentTemplate(stackSummary.name),
+            getStackPolicy(stackSummary.name),
+            describeStack(stackSummary.name),
+        ]);
+        if (!stack) {
+            throw new Error(`Expected stack '${stackSummary.name}' to exist`);
+        }
+        const parameterMap = new Map(stack.parameters.map((p) => [p.key, p]));
+        const parameters = summary.parameters.map((declaration) => {
+            const stackParam = parameterMap.get(declaration.key);
+            if (!stackParam) {
+                throw new Error(`Parameter '${declaration.key}' not found`);
+            }
+            return {
+                ...stackParam,
+                ...declaration,
+            };
+        });
+        return {
+            ...stack,
+            templateBody,
+            stackPolicyBody,
+            parameters,
+        };
+    };
+    const getTemplateSummary = (input) => (0, client_1.withClientScheduler)(client, (0, takomo_util_1.uuid)(), getTemplateSummaryScheduler, (c) => c.getTemplateSummary(input).then(convert_1.convertTemplateSummary));
+    const getCurrentTemplate = (stackName) => client
+        .getTemplate({ StackName: stackName, TemplateStage: "Original" })
+        .then((res) => res.TemplateBody);
+    const initiateStackDeletion = (input) => client.deleteStack(input).then(() => true);
+    const createChangeSet = (params) => client.createChangeSet(params).then((res) => res.Id);
+    const deleteChangeSet = (stackName, changeSetName) => {
+        const params = {
+            StackName: stackName,
+            ChangeSetName: changeSetName,
+        };
+        return client.deleteChangeSet(params).then(() => true);
+    };
+    const describeChangeSet = (stackName, changeSetName) => {
+        const params = {
+            ChangeSetName: changeSetName,
+            StackName: stackName,
+        };
+        return client.describeChangeSet(params).then(convert_1.convertChangeSet);
+    };
+    const waitUntilChangeSetIsReady = async (stackName, changeSetName) => {
+        const changeSet = await describeChangeSet(stackName, changeSetName);
+        const result = (0, describe_change_set_rule_1.evaluateDescribeChangeSet)(changeSet);
+        switch (result) {
+            case "ERROR":
+                throw new Error(`Could not evaluate change set with status: ${changeSet.status}, reason: ${changeSet.statusReason}`);
+            case "NO_CHANGES":
+                return undefined;
+            case "FAILED":
+                throw new Error(changeSet.statusReason);
+            case "PENDING":
+                await (0, takomo_util_1.sleep)(1000);
+                return waitUntilChangeSetIsReady(stackName, changeSetName);
+            case "READY":
+                return changeSet;
+        }
+    };
+    const describeStackEvents = (stackName) => (0, client_1.pagedOperationBulkhead)(describeEventsBulkhead, (params) => client.describeStackEvents(params), { StackName: stackName }, convert_1.convertStackEvents);
+    const cancelStackUpdate = (stackName) => {
+        const params = {
+            StackName: stackName,
+            ClientRequestToken: (0, takomo_util_1.uuid)(),
+        };
+        return client
+            .cancelUpdateStack(params)
+            .then(() => params.ClientRequestToken);
+    };
+    const continueUpdateRollback = (stackNameOrId) => {
+        const params = {
+            StackName: stackNameOrId,
+            ClientRequestToken: (0, takomo_util_1.uuid)(),
+        };
+        return client
+            .continueUpdateRollback(params)
+            .then(() => params.ClientRequestToken);
+    };
+    const createStack = (params) => client.createStack(params).then((res) => res.StackId);
+    const updateStack = (params) => client
+        .updateStack(params)
+        .then(() => true)
+        .catch((e) => {
+        if (e.Code === "ValidationError" &&
+            e.message === "No updates are to be performed.") {
+            return false;
+        }
+        throw e;
+    });
+    const updateTerminationProtection = (stackName, enable) => client
+        .updateTerminationProtection({
+        EnableTerminationProtection: enable,
+        StackName: stackName,
+    })
+        .then(() => true);
+    const waitStackDeployToComplete = async (props) => {
+        const { stackId, clientToken, eventListener, timeoutConfig, allEvents = [], latestEventId, } = props;
+        await (0, takomo_util_1.sleep)(waitStackDeployToCompletePollInterval);
+        const events = (await describeStackEvents(stackId)).slice().reverse();
+        const newEvents = (0, lodash_takerightwhile_1.default)(events, (e) => e.id !== latestEventId).filter((e) => e.clientRequestToken === clientToken);
+        newEvents.forEach(eventListener);
+        const updatedEvents = [...allEvents, ...newEvents];
+        const terminalEvent = findTerminalEvent(stackId, updatedEvents);
+        if (terminalEvent) {
+            return {
+                timeoutConfig,
+                events: updatedEvents,
+                stackStatus: terminalEvent.resourceStatus,
+            };
+        }
+        const latestEvent = ramda_1.default.last(events);
+        const newLatestEventId = latestEvent ? latestEvent.id : latestEventId;
+        if (timeoutConfig.timeout !== 0) {
+            const elapsedTime = Date.now() - timeoutConfig.startTime;
+            if (elapsedTime > timeoutConfig.timeout * 1000) {
+                const latestStackEvent = ramda_1.default.last(updatedEvents.filter(({ resourceType, physicalResourceId }) => resourceType === "AWS::CloudFormation::Stack" &&
+                    physicalResourceId === stackId));
+                if (!latestStackEvent) {
+                    throw new Error(`Expected latest event to exist for stack ${stackId}`);
+                }
+                if (latestStackEvent.resourceStatus === "UPDATE_IN_PROGRESS") {
+                    const cancelToken = await cancelStackUpdate(stackId);
+                    return waitStackDeployToComplete({
+                        ...props,
+                        clientToken: cancelToken,
+                        allEvents: updatedEvents,
+                        latestEventId: newLatestEventId,
+                        timeoutConfig: {
+                            timeout: 0,
+                            timeoutOccurred: true,
+                            startTime: timeoutConfig.startTime,
+                        },
+                    });
+                }
+                else {
+                    logger.warn(`Timeout exceeded for stack ${stackId} but update can't be cancelled because stack status ${latestStackEvent.resourceStatus} != UPDATE_IN_PROGRESS`);
+                }
+            }
+        }
+        return waitStackDeployToComplete({
+            ...props,
+            allEvents: updatedEvents,
+            latestEventId: newLatestEventId,
+        });
+    };
+    const waitStackDeleteToComplete = async (props) => {
+        const { stackId, latestEventId, clientToken, eventListener, allEvents = [], } = props;
+        await (0, takomo_util_1.sleep)(waitStackDeleteToCompletePollInterval);
+        const events = (await describeStackEvents(stackId)).slice().reverse();
+        const newEvents = (0, lodash_takerightwhile_1.default)(events, (e) => e.id !== latestEventId).filter((e) => e.clientRequestToken === clientToken);
+        newEvents.forEach(eventListener);
+        const updatedEvents = [...allEvents, ...newEvents];
+        const terminalEvent = findTerminalEvent(stackId, updatedEvents);
+        if (terminalEvent) {
+            return {
+                events: updatedEvents,
+                stackStatus: terminalEvent.resourceStatus,
+            };
+        }
+        const latestEvent = ramda_1.default.last(events);
+        const newLatestEventId = latestEvent ? latestEvent.id : latestEventId;
+        return waitStackDeleteToComplete({
+            ...props,
+            latestEventId: newLatestEventId,
+            allEvents: updatedEvents,
+        });
+    };
+    const waitStackRollbackToComplete = async (props) => {
+        const { stackId, latestEventId, clientToken, eventListener, allEvents = [], } = props;
+        await (0, takomo_util_1.sleep)(waitStackRollbackToCompletePollInterval);
+        const events = (await describeStackEvents(stackId)).slice().reverse();
+        const newEvents = (0, lodash_takerightwhile_1.default)(events, (e) => e.id !== latestEventId).filter((e) => e.clientRequestToken === clientToken);
+        newEvents.forEach(eventListener);
+        const updatedEvents = [...allEvents, ...newEvents];
+        const terminalEvent = findTerminalEvent(stackId, updatedEvents);
+        if (terminalEvent) {
+            const stack = await describeStack(stackId);
+            if (!stack) {
+                throw new Error(`Expected stack ${stackId} to be found`);
+            }
+            return {
+                events: updatedEvents,
+                stackStatus: stack.status,
+            };
+        }
+        const latestEvent = ramda_1.default.last(events);
+        const newLatestEventId = latestEvent ? latestEvent.id : latestEventId;
+        return waitStackRollbackToComplete({
+            ...props,
+            latestEventId: newLatestEventId,
+            allEvents: updatedEvents,
+        });
+    };
+    const getNativeClient = async () => client;
+    return {
+        continueUpdateRollback,
+        validateTemplate,
+        describeStack,
+        listNotDeletedStacks,
+        getNotDeletedStack,
+        enrichStack,
+        enrichStackSummary,
+        getTemplateSummary,
+        getCurrentTemplate,
+        initiateStackDeletion,
+        createChangeSet,
+        deleteChangeSet,
+        describeChangeSet,
+        waitUntilChangeSetIsReady,
+        describeStackEvents,
+        cancelStackUpdate,
+        createStack,
+        updateStack,
+        updateTerminationProtection,
+        waitStackDeployToComplete,
+        waitStackDeleteToComplete,
+        getStackPolicy,
+        detectDrift,
+        describeStackDriftDetectionStatus,
+        waitDriftDetectionToComplete,
+        waitStackRollbackToComplete,
+        getNativeClient,
+    };
+};
+exports.createCloudFormationClient = createCloudFormationClient;
+//# sourceMappingURL=client.js.map