sst 2.48.5 → 2.49.2

package/cdk/deploy-stack.js

@@ -1,520 +0,0 @@
-import * as uuid from "uuid";
-import { AssetManifestBuilder } from "sst-aws-cdk/lib/api/deployments/asset-manifest-builder.js";
-import { publishAssets } from "sst-aws-cdk/lib/api/deployments/asset-publishing.js";
-import { addMetadataAssetsToManifest } from "sst-aws-cdk/lib/api/deployments/assets.js";
-import { determineAllowCrossAccountAssetPublishing } from "sst-aws-cdk/lib/api/deployments/checks.js";
-import { changeSetHasNoChanges, CloudFormationStack, TemplateParameters, waitForChangeSet, waitForStackDeploy, waitForStackDelete, } from "sst-aws-cdk/lib/api/deployments/cloudformation.js";
-import { tryHotswapDeployment } from "sst-aws-cdk/lib/api/deployments/hotswap-deployments.js";
-import { debug, info, warning } from "sst-aws-cdk/lib/logging.js";
-import { ToolkitError } from "sst-aws-cdk/lib/toolkit/error.js";
-import { formatErrorMessage } from "sst-aws-cdk/lib/util/error.js";
-import { CfnEvaluationException } from "sst-aws-cdk/lib/api/evaluate-cloudformation-template.js";
-import { HotswapMode, HotswapPropertyOverrides, } from "sst-aws-cdk/lib/api/hotswap/common.js";
-import { makeBodyParameter, } from "sst-aws-cdk/lib/api/util/template-body-parameter.js";
-import { callWithRetry } from "./util.js";
-export async function deployStack(options) {
-    const stackArtifact = options.stack;
-    const stackEnv = options.resolvedEnvironment;
-    options.sdk.appendCustomUserAgent(options.extraUserAgent);
-    const cfn = options.sdk.cloudFormation();
-    const deployName = options.deployName || stackArtifact.stackName;
-    let cloudFormationStack = await callWithRetry(() => CloudFormationStack.lookup(cfn, deployName));
-    if (cloudFormationStack.stackStatus.isCreationFailure) {
-        debug(`Found existing stack ${deployName} that had previously failed creation. Deleting it before attempting to re-create it.`);
-        await cfn.deleteStack({ StackName: deployName });
-        const deletedStack = await waitForStackDelete(cfn, deployName);
-        if (deletedStack && deletedStack.stackStatus.name !== "DELETE_COMPLETE") {
-            throw new ToolkitError(`Failed deleting stack ${deployName} that had previously failed creation (current state: ${deletedStack.stackStatus})`);
-        }
-        // Update variable to mark that the stack does not exist anymore, but avoid
-        // doing an actual lookup in CloudFormation (which would be silly to do if
-        // we just deleted it).
-        cloudFormationStack = CloudFormationStack.doesNotExist(cfn, deployName);
-    }
-    // Detect "legacy" assets (which remain in the metadata) and publish them via
-    // an ad-hoc asset manifest, while passing their locations via template
-    // parameters.
-    const legacyAssets = new AssetManifestBuilder();
-    const assetParams = await addMetadataAssetsToManifest(stackArtifact, legacyAssets, options.envResources, options.reuseAssets);
-    const finalParameterValues = { ...options.parameters, ...assetParams };
-    const templateParams = TemplateParameters.fromTemplate(stackArtifact.template);
-    const stackParams = options.usePreviousParameters
-        ? templateParams.updateExisting(finalParameterValues, cloudFormationStack.parameters)
-        : templateParams.supplyAll(finalParameterValues);
-    if (await canSkipDeploy(options, cloudFormationStack, stackParams.hasChanges(cloudFormationStack.parameters))) {
-        debug(`${deployName}: skipping deployment (use --force to override)`);
-        // if we can skip deployment and we are performing a hotswap, let the user know
-        // that no hotswap deployment happened
-        if (options.hotswap) {
-        }
-        return {
-            type: "did-deploy-stack",
-            noOp: true,
-            outputs: cloudFormationStack.outputs,
-            stackArn: cloudFormationStack.stackId,
-        };
-    }
-    else {
-        debug(`${deployName}: deploying...`);
-    }
-    const bodyParameter = await makeBodyParameter(stackArtifact, options.resolvedEnvironment, legacyAssets, options.envResources, options.overrideTemplate);
-    let bootstrapStackName;
-    try {
-        bootstrapStackName = (await options.envResources.lookupToolkit()).stackName;
-    }
-    catch (e) {
-        debug(`Could not determine the bootstrap stack name: ${e}`);
-    }
-    await publishAssets(legacyAssets.toManifest(stackArtifact.assembly.directory), options.sdkProvider, stackEnv, {
-        parallel: options.assetParallelism,
-        allowCrossAccount: await determineAllowCrossAccountAssetPublishing(options.sdk, bootstrapStackName),
-    });
-    const hotswapMode = options.hotswap;
-    const hotswapPropertyOverrides = options.hotswapPropertyOverrides ?? new HotswapPropertyOverrides();
-    if (hotswapMode && hotswapMode !== HotswapMode.FULL_DEPLOYMENT) {
-        // attempt to short-circuit the deployment if possible
-        try {
-            const hotswapDeploymentResult = await tryHotswapDeployment(options.sdkProvider, stackParams.values, cloudFormationStack, stackArtifact, hotswapMode, hotswapPropertyOverrides);
-            if (hotswapDeploymentResult) {
-                return hotswapDeploymentResult;
-            }
-            info("Could not perform a hotswap deployment, as the stack %s contains non-Asset changes", stackArtifact.displayName);
-        }
-        catch (e) {
-            if (!(e instanceof CfnEvaluationException)) {
-                throw e;
-            }
-            info("Could not perform a hotswap deployment, because the CloudFormation template could not be resolved: %s", formatErrorMessage(e));
-        }
-        if (hotswapMode === HotswapMode.FALL_BACK) {
-            info("Falling back to doing a full deployment");
-            options.sdk.appendCustomUserAgent("cdk-hotswap/fallback");
-        }
-        else {
-            return {
-                type: "did-deploy-stack",
-                noOp: true,
-                stackArn: cloudFormationStack.stackId,
-                outputs: cloudFormationStack.outputs,
-            };
-        }
-    }
-    // could not short-circuit the deployment, perform a full CFN deploy instead
-    const fullDeployment = new FullCloudFormationDeployment(options, cloudFormationStack, stackArtifact, stackParams, bodyParameter);
-    return fullDeployment.performDeployment();
-}
-/**
- * This class shares state and functionality between the different full deployment modes
- */
-class FullCloudFormationDeployment {
-    options;
-    cloudFormationStack;
-    stackArtifact;
-    stackParams;
-    bodyParameter;
-    cfn;
-    stackName;
-    update;
-    verb;
-    uuid;
-    constructor(options, cloudFormationStack, stackArtifact, stackParams, bodyParameter) {
-        this.options = options;
-        this.cloudFormationStack = cloudFormationStack;
-        this.stackArtifact = stackArtifact;
-        this.stackParams = stackParams;
-        this.bodyParameter = bodyParameter;
-        this.cfn = options.sdk.cloudFormation();
-        this.stackName = options.deployName ?? stackArtifact.stackName;
-        this.update =
-            cloudFormationStack.exists &&
-                cloudFormationStack.stackStatus.name !== "REVIEW_IN_PROGRESS";
-        this.verb = this.update ? "update" : "create";
-        this.uuid = uuid.v4();
-    }
-    async performDeployment() {
-        const deploymentMethod = this.options.deploymentMethod ?? {
-            method: "change-set",
-        };
-        if (deploymentMethod.method === "direct" &&
-            this.options.resourcesToImport) {
-            throw new ToolkitError("Importing resources requires a changeset deployment");
-        }
-        switch (deploymentMethod.method) {
-            case "change-set":
-                return this.changeSetDeployment(deploymentMethod);
-            case "direct":
-                return this.directDeployment();
-        }
-    }
-    async changeSetDeployment(deploymentMethod) {
-        const changeSetName = deploymentMethod.changeSetName ?? "cdk-deploy-change-set";
-        const execute = deploymentMethod.execute ?? true;
-        const importExistingResources = deploymentMethod.importExistingResources ?? false;
-        const changeSetDescription = await this.createChangeSet(changeSetName, execute, importExistingResources);
-        await this.updateTerminationProtection();
-        if (changeSetHasNoChanges(changeSetDescription)) {
-            debug("No changes are to be performed on %s.", this.stackName);
-            if (execute) {
-                debug("Deleting empty change set %s", changeSetDescription.ChangeSetId);
-                await this.cfn.deleteChangeSet({
-                    StackName: this.stackName,
-                    ChangeSetName: changeSetName,
-                });
-            }
-            if (this.options.force) {
-                warning([
-                    "You used the --force flag, but CloudFormation reported that the deployment would not make any changes.",
-                    "According to CloudFormation, all resources are already up-to-date with the state in your CDK app.",
-                    "",
-                    "You cannot use the --force flag to get rid of changes you made in the console. Try using",
-                    "CloudFormation drift detection instead: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-stack-drift.html",
-                ].join("\n"));
-            }
-            return {
-                type: "did-deploy-stack",
-                noOp: true,
-                outputs: this.cloudFormationStack.outputs,
-                stackArn: changeSetDescription.StackId,
-            };
-        }
-        if (!execute) {
-            info("Changeset %s created and waiting in review for manual execution (--no-execute)", changeSetDescription.ChangeSetId);
-            return {
-                type: "did-deploy-stack",
-                noOp: false,
-                outputs: this.cloudFormationStack.outputs,
-                stackArn: changeSetDescription.StackId,
-            };
-        }
-        // If there are replacements in the changeset, check the rollback flag and stack status
-        const replacement = hasReplacement(changeSetDescription);
-        const isPausedFailState = this.cloudFormationStack.stackStatus.isRollbackable;
-        const rollback = this.options.rollback ?? true;
-        if (isPausedFailState && replacement) {
-            return {
-                type: "failpaused-need-rollback-first",
-                reason: "replacement",
-                status: this.cloudFormationStack.stackStatus.name,
-            };
-        }
-        if (isPausedFailState && rollback) {
-            return {
-                type: "failpaused-need-rollback-first",
-                reason: "not-norollback",
-                status: this.cloudFormationStack.stackStatus.name,
-            };
-        }
-        if (!rollback && replacement) {
-            return { type: "replacement-requires-rollback" };
-        }
-        return this.executeChangeSet(changeSetDescription);
-    }
-    async createChangeSet(changeSetName, willExecute, importExistingResources) {
-        await this.cleanupOldChangeset(changeSetName);
-        debug(`Attempting to create ChangeSet with name ${changeSetName} to ${this.verb} stack ${this.stackName}`);
-        const changeSet = await this.cfn.createChangeSet({
-            StackName: this.stackName,
-            ChangeSetName: changeSetName,
-            ChangeSetType: this.options.resourcesToImport
-                ? "IMPORT"
-                : this.update
-                    ? "UPDATE"
-                    : "CREATE",
-            ResourcesToImport: this.options.resourcesToImport,
-            Description: `CDK Changeset for execution ${this.uuid}`,
-            ClientToken: `create${this.uuid}`,
-            ImportExistingResources: importExistingResources,
-            ...this.commonPrepareOptions(),
-        });
-        debug("Initiated creation of changeset: %s; waiting for it to finish creating...", changeSet.Id);
-        // Fetching all pages if we'll execute, so we can have the correct change count when monitoring.
-        return waitForChangeSet(this.cfn, this.stackName, changeSetName, {
-            fetchAll: willExecute,
-        });
-    }
-    async executeChangeSet(changeSet) {
-        debug("Initiating execution of changeset %s on stack %s", changeSet.ChangeSetId, this.stackName);
-        await this.cfn.executeChangeSet({
-            StackName: this.stackName,
-            ChangeSetName: changeSet.ChangeSetName,
-            ClientRequestToken: `exec${this.uuid}`,
-            ...this.commonExecuteOptions(),
-        });
-        debug("Execution of changeset %s on stack %s has started; waiting for the update to complete...", changeSet.ChangeSetId, this.stackName);
-        // +1 for the extra event emitted from updates.
-        const changeSetLength = (changeSet.Changes ?? []).length + (this.update ? 1 : 0);
-        return this.monitorDeployment(changeSet.CreationTime, changeSetLength);
-    }
-    async cleanupOldChangeset(changeSetName) {
-        if (this.cloudFormationStack.exists) {
-            // Delete any existing change sets generated by CDK since change set names must be unique.
-            // The delete request is successful as long as the stack exists (even if the change set does not exist).
-            debug(`Removing existing change set with name ${changeSetName} if it exists`);
-            await this.cfn.deleteChangeSet({
-                StackName: this.stackName,
-                ChangeSetName: changeSetName,
-            });
-        }
-    }
-    async updateTerminationProtection() {
-        // Update termination protection only if it has changed.
-        const terminationProtection = this.stackArtifact.terminationProtection ?? false;
-        if (!!this.cloudFormationStack.terminationProtection !== terminationProtection) {
-            debug("Updating termination protection from %s to %s for stack %s", this.cloudFormationStack.terminationProtection, terminationProtection, this.stackName);
-            await this.cfn.updateTerminationProtection({
-                StackName: this.stackName,
-                EnableTerminationProtection: terminationProtection,
-            });
-            debug("Termination protection updated to %s for stack %s", terminationProtection, this.stackName);
-        }
-    }
-    async directDeployment() {
-        const startTime = new Date();
-        if (this.update) {
-            await this.updateTerminationProtection();
-            try {
-                await this.cfn.updateStack({
-                    StackName: this.stackName,
-                    ClientRequestToken: `update${this.uuid}`,
-                    ...this.commonPrepareOptions(),
-                    ...this.commonExecuteOptions(),
-                });
-            }
-            catch (err) {
-                if (err.message === "No updates are to be performed.") {
-                    debug("No updates are to be performed for stack %s", this.stackName);
-                    return {
-                        type: "did-deploy-stack",
-                        noOp: true,
-                        outputs: this.cloudFormationStack.outputs,
-                        stackArn: this.cloudFormationStack.stackId,
-                    };
-                }
-                throw err;
-            }
-            if (this.options.noMonitor)
-                return;
-            return this.monitorDeployment(startTime, undefined);
-        }
-        else {
-            // Take advantage of the fact that we can set termination protection during create
-            const terminationProtection = this.stackArtifact.terminationProtection ?? false;
-            await this.cfn.createStack({
-                StackName: this.stackName,
-                ClientRequestToken: `create${this.uuid}`,
-                ...(terminationProtection
-                    ? { EnableTerminationProtection: true }
-                    : undefined),
-                ...this.commonPrepareOptions(),
-                ...this.commonExecuteOptions(),
-            });
-            if (this.options.noMonitor)
-                return;
-            return this.monitorDeployment(startTime, undefined);
-        }
-    }
-    async monitorDeployment(startTime, expectedChanges) {
-        //    const monitor = this.options.quiet
-        //      ? undefined
-        //      : StackActivityMonitor.withDefaultPrinter(
-        //          this.cfn,
-        //          this.stackName,
-        //          this.stackArtifact,
-        //          {
-        //            resourcesTotal: expectedChanges,
-        //            progress: this.options.progress,
-        //            changeSetCreationTime: startTime,
-        //            ci: this.options.ci,
-        //          }
-        //        ).start();
-        let finalState = this.cloudFormationStack;
-        try {
-            const successStack = await waitForStackDeploy(this.cfn, this.stackName);
-            // This shouldn't really happen, but catch it anyway. You never know.
-            if (!successStack) {
-                throw new ToolkitError("Stack deploy failed (the stack disappeared while we were deploying it)");
-            }
-            finalState = successStack;
-        }
-        catch (e) {
-            throw new ToolkitError(suffixWithErrors(formatErrorMessage(e) /*, monitor?.errors*/));
-        }
-        finally {
-            // await monitor?.stop();
-        }
-        debug("Stack %s has completed updating", this.stackName);
-        return {
-            type: "did-deploy-stack",
-            noOp: false,
-            outputs: finalState.outputs,
-            stackArn: finalState.stackId,
-        };
-    }
-    /**
-     * Return the options that are shared between CreateStack, UpdateStack and CreateChangeSet
-     */
-    commonPrepareOptions() {
-        return {
-            Capabilities: [
-                "CAPABILITY_IAM",
-                "CAPABILITY_NAMED_IAM",
-                "CAPABILITY_AUTO_EXPAND",
-            ],
-            NotificationARNs: this.options.notificationArns,
-            Parameters: this.stackParams.apiParameters,
-            RoleARN: this.options.roleArn,
-            TemplateBody: this.bodyParameter.TemplateBody,
-            TemplateURL: this.bodyParameter.TemplateURL,
-            Tags: this.options.tags,
-        };
-    }
-    /**
-     * Return the options that are shared between UpdateStack and CreateChangeSet
-     *
-     * Be careful not to add in keys for options that aren't used, as the features may not have been
-     * deployed everywhere yet.
-     */
-    commonExecuteOptions() {
-        const shouldDisableRollback = this.options.rollback === false;
-        return {
-            StackName: this.stackName,
-            ...(shouldDisableRollback ? { DisableRollback: true } : undefined),
-        };
-    }
-}
-export async function destroyStack(options) {
-    const deployName = options.deployName || options.stack.stackName;
-    const cfn = options.sdk.cloudFormation();
-    const currentStack = await CloudFormationStack.lookup(cfn, deployName);
-    if (!currentStack.exists) {
-        return;
-    }
-    /*
-    const monitor = options.quiet
-      ? undefined
-      : StackActivityMonitor.withDefaultPrinter(cfn, deployName, options.stack, {
-        ci: options.ci,
-      }).start();
-    */
-    try {
-        await cfn.deleteStack({ StackName: deployName, RoleARN: options.roleArn });
-        const destroyedStack = await waitForStackDelete(cfn, deployName);
-        if (destroyedStack &&
-            destroyedStack.stackStatus.name !== "DELETE_COMPLETE") {
-            throw new ToolkitError(`Failed to destroy ${deployName}: ${destroyedStack.stackStatus}`);
-        }
-    }
-    catch (e) {
-        throw new ToolkitError(suffixWithErrors(formatErrorMessage(e) /* , monitor?.errors */));
-    }
-    finally {
-        /*
-        if (monitor) {
-          await monitor.stop();
-        }
-        */
-    }
-}
-/**
- * Checks whether we can skip deployment
- *
- * We do this in a complicated way by preprocessing (instead of just
- * looking at the changeset), because if there are nested stacks involved
- * the changeset will always show the nested stacks as needing to be
- * updated, and the deployment will take a long time to in effect not
- * do anything.
- */
-async function canSkipDeploy(deployStackOptions, cloudFormationStack, parameterChanges) {
-    const deployName = deployStackOptions.deployName || deployStackOptions.stack.stackName;
-    debug(`${deployName}: checking if we can skip deploy`);
-    // Forced deploy
-    if (deployStackOptions.force) {
-        debug(`${deployName}: forced deployment`);
-        return false;
-    }
-    // Creating changeset only (default true), never skip
-    if (deployStackOptions.deploymentMethod?.method === "change-set" &&
-        deployStackOptions.deploymentMethod.execute === false) {
-        debug(`${deployName}: --no-execute, always creating change set`);
-        return false;
-    }
-    // No existing stack
-    if (!cloudFormationStack.exists) {
-        debug(`${deployName}: no existing stack`);
-        return false;
-    }
-    // SST check: stack is not busy
-    if (cloudFormationStack.stackStatus.isInProgress) {
-        debug(`${deployName}: stack is busy`);
-        return false;
-    }
-    // Template has changed (assets taken into account here)
-    if (JSON.stringify(deployStackOptions.stack.template) !==
-        JSON.stringify(await cloudFormationStack.template())) {
-        debug(`${deployName}: template has changed`);
-        return false;
-    }
-    // Tags have changed
-    if (!compareTags(cloudFormationStack.tags, deployStackOptions.tags ?? [])) {
-        debug(`${deployName}: tags have changed`);
-        return false;
-    }
-    // Notification arns have changed
-    if (!arrayEquals(cloudFormationStack.notificationArns, deployStackOptions.notificationArns ?? [])) {
-        debug(`${deployName}: notification arns have changed`);
-        return false;
-    }
-    // Termination protection has been updated
-    if (!!deployStackOptions.stack.terminationProtection !==
-        !!cloudFormationStack.terminationProtection) {
-        debug(`${deployName}: termination protection has been updated`);
-        return false;
-    }
-    // Parameters have changed
-    if (parameterChanges) {
-        if (parameterChanges === "ssm") {
-            debug(`${deployName}: some parameters come from SSM so we have to assume they may have changed`);
-        }
-        else {
-            debug(`${deployName}: parameters have changed`);
-        }
-        return false;
-    }
-    // Existing stack is in a failed state
-    if (cloudFormationStack.stackStatus.isFailure) {
-        debug(`${deployName}: stack is in a failure state`);
-        return false;
-    }
-    // We can skip deploy
-    return true;
-}
-/**
- * Compares two list of tags, returns true if identical.
- */
-function compareTags(a, b) {
-    if (a.length !== b.length) {
-        return false;
-    }
-    for (const aTag of a) {
-        const bTag = b.find((tag) => tag.Key === aTag.Key);
-        if (!bTag || bTag.Value !== aTag.Value) {
-            return false;
-        }
-    }
-    return true;
-}
-function suffixWithErrors(msg, errors) {
-    return errors && errors.length > 0 ? `${msg}: ${errors.join(", ")}` : msg;
-}
-function arrayEquals(a, b) {
-    return (a.every((item) => b.includes(item)) && b.every((item) => a.includes(item)));
-}
-function hasReplacement(cs) {
-    return (cs.Changes ?? []).some((c) => {
-        // @ts-ignore
-        const a = c.ResourceChange?.PolicyAction;
-        return (a === "ReplaceAndDelete" ||
-            a === "ReplaceAndRetain" ||
-            a === "ReplaceAndSnapshot");
-    });
-}

package/cdk/deployments-wrapper.d.ts

@@ -1,3 +0,0 @@
-import { SdkProvider } from "sst-aws-cdk/lib/api/aws-auth/sdk-provider.js";
-import { DeployStackOptions as PublishStackAssetsOptions } from "./deployments.js";
-export declare function publishDeployAssets(sdkProvider: SdkProvider, options: PublishStackAssetsOptions): Promise<any>;

package/cdk/deployments-wrapper.js

@@ -1,117 +0,0 @@
-import * as cxapi from "@aws-cdk/cx-api";
-import { AssetManifestBuilder } from "sst-aws-cdk/lib/api/deployments/asset-manifest-builder.js";
-import { AssetManifest } from "cdk-assets";
-import { debug } from "sst-aws-cdk/lib/logging.js";
-import { CloudFormationStack, TemplateParameters, waitForStackDelete, } from "sst-aws-cdk/lib/api/deployments/cloudformation.js";
-import { addMetadataAssetsToManifest } from "sst-aws-cdk/lib/api/deployments/assets.js";
-import { makeBodyParameter } from "sst-aws-cdk/lib/api/util/template-body-parameter.js";
-import { publishAssets, Deployments, } from "./deployments.js";
-import { lazy } from "../util/lazy.js";
-export async function publishDeployAssets(sdkProvider, options) {
-    const { deployment, envResources, stackSdk, resolvedEnvironment, executionRoleArn, } = await useDeployment().get(sdkProvider, options);
-    const assetArtifacts = options.stack.dependencies.filter(cxapi.AssetManifestArtifact.isAssetManifestArtifact);
-    for (const asset of assetArtifacts) {
-        const manifest = AssetManifest.fromFile(asset.file);
-        await publishAssets(manifest, sdkProvider, resolvedEnvironment, {
-            quiet: options.quiet,
-        });
-    }
-    return deployStack({
-        stack: options.stack,
-        noMonitor: true,
-        resolvedEnvironment,
-        deployName: options.deployName,
-        notificationArns: options.notificationArns,
-        quiet: options.quiet,
-        sdk: stackSdk,
-        sdkProvider,
-        roleArn: executionRoleArn,
-        reuseAssets: options.reuseAssets,
-        envResources,
-        tags: options.tags,
-        deploymentMethod: options.deploymentMethod,
-        force: options.force,
-        parameters: options.parameters,
-        usePreviousParameters: options.usePreviousParameters,
-        progress: options.progress,
-        ci: options.ci,
-        rollback: options.rollback,
-        hotswap: options.hotswap,
-        extraUserAgent: options.extraUserAgent,
-        resourcesToImport: options.resourcesToImport,
-        overrideTemplate: options.overrideTemplate,
-        assetParallelism: options.assetParallelism,
-    });
-}
-const useDeployment = lazy(() => {
-    const state = new Map();
-    return {
-        async get(sdkProvider, options) {
-            const region = options.stack.environment.region;
-            if (!state.has(region)) {
-                const deployment = new Deployments({ sdkProvider });
-                const env = await deployment.envs.accessStackForMutableStackOperations(options.stack);
-                const envResources = env.resources;
-                const executionRoleArn = await env.replacePlaceholders(options.roleArn ?? options.stack.cloudFormationExecutionRoleArn);
-                // Do a verification of the bootstrap stack version
-                await deployment.validateBootstrapStackVersion(options.stack.stackName, options.stack.requiresBootstrapStackVersion, options.stack.bootstrapStackVersionSsmParameter, envResources);
-                state.set(region, {
-                    deployment,
-                    envResources,
-                    stackSdk: env.sdk,
-                    resolvedEnvironment: env.resolvedEnvironment,
-                    executionRoleArn,
-                });
-            }
-            return state.get(region);
-        },
-    };
-});
-async function deployStack(options) {
-    const stackArtifact = options.stack;
-    const stackEnv = options.resolvedEnvironment;
-    options.sdk.appendCustomUserAgent(options.extraUserAgent);
-    const cfn = options.sdk.cloudFormation();
-    const deployName = options.deployName || stackArtifact.stackName;
-    let cloudFormationStack = await CloudFormationStack.lookup(cfn, deployName);
-    if (cloudFormationStack.stackStatus.isCreationFailure) {
-        debug(`Found existing stack ${deployName} that had previously failed creation. Deleting it before attempting to re-create it.`);
-        await cfn.deleteStack({ StackName: deployName });
-        const deletedStack = await waitForStackDelete(cfn, deployName);
-        if (deletedStack && deletedStack.stackStatus.name !== "DELETE_COMPLETE") {
-            throw new Error(`Failed deleting stack ${deployName} that had previously failed creation (current state: ${deletedStack.stackStatus})`);
-        }
-        // Update variable to mark that the stack does not exist anymore, but avoid
-        // doing an actual lookup in CloudFormation (which would be silly to do if
-        // we just deleted it).
-        cloudFormationStack = CloudFormationStack.doesNotExist(cfn, deployName);
-    }
-    // Detect "legacy" assets (which remain in the metadata) and publish them via
-    // an ad-hoc asset manifest, while passing their locations via template
-    // parameters.
-    const legacyAssets = new AssetManifestBuilder();
-    const assetParams = await addMetadataAssetsToManifest(stackArtifact, legacyAssets, options.envResources, options.reuseAssets);
-    const finalParameterValues = { ...options.parameters, ...assetParams };
-    const templateParams = TemplateParameters.fromTemplate(stackArtifact.template);
-    const stackParams = options.usePreviousParameters
-        ? templateParams.updateExisting(finalParameterValues, cloudFormationStack.parameters)
-        : templateParams.supplyAll(finalParameterValues);
-    const bodyParameter = await makeBodyParameter(stackArtifact, options.resolvedEnvironment, legacyAssets, options.envResources, options.overrideTemplate);
-    await publishAssets(legacyAssets.toManifest(stackArtifact.assembly.directory), options.sdkProvider, stackEnv, { quiet: options.quiet });
-    return {
-        isUpdate: cloudFormationStack.exists &&
-            cloudFormationStack.stackStatus.name !== "REVIEW_IN_PROGRESS",
-        params: {
-            StackName: deployName,
-            TemplateBody: bodyParameter.TemplateBody,
-            TemplateURL: bodyParameter.TemplateURL,
-            Parameters: stackParams.apiParameters,
-            Capabilities: [
-                "CAPABILITY_IAM",
-                "CAPABILITY_NAMED_IAM",
-                "CAPABILITY_AUTO_EXPAND",
-            ],
-            Tags: options.tags,
-        },
-    };
-}