sst 2.0.0-rc.38 → 2.0.0-rc.39

package/cdk/cloudformation-deployments-wrapper.d.ts

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

package/cdk/cloudformation-deployments-wrapper.js

@@ -1,7 +1,14 @@
+import { debug } from "aws-cdk/lib/logging.js";
+import { CloudFormationStack, TemplateParameters, waitForStackDelete, } from "aws-cdk/lib/api/util/cloudformation.js";
 import { ToolkitInfo } from "aws-cdk/lib/api/toolkit-info.js";
+import { addMetadataAssetsToManifest } from "aws-cdk/lib/assets.js";
+import { publishAssets } from "aws-cdk/lib/util/asset-publishing.js";
+import { AssetManifestBuilder } from "aws-cdk/lib/util/asset-manifest-builder.js";
+import { CloudFormationDeployments, } from "./cloudformation-deployments.js";
+import { makeBodyParameter } from "./deploy-stack.js";
 import { Context } from "../context/context.js";
-export async function publishAssets(deployment, options) {
-    const toolkitInfo = await useToolkitInfo().lookup(deployment, options);
+export async function publishDeployAssets(sdkProvider, options) {
+    const { deployment, toolkitInfo, stackSdk, resolvedEnvironment, cloudFormationRoleArn, } = await useDeployment().get(sdkProvider, options);
     await deployment.publishStackAssets(options.stack, toolkitInfo, {
         buildAssets: options.buildAssets ?? true,
         publishOptions: {
@@ -9,17 +16,97 @@ export async function publishAssets(deployment, options) {
             parallel: options.assetParallelism,
         },
     });
+    return deployStack({
+        stack: options.stack,
+        noMonitor: true,
+        resolvedEnvironment,
+        deployName: options.deployName,
+        notificationArns: options.notificationArns,
+        quiet: options.quiet,
+        sdk: stackSdk,
+        sdkProvider,
+        roleArn: cloudFormationRoleArn,
+        reuseAssets: options.reuseAssets,
+        toolkitInfo,
+        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 useToolkitInfo = Context.memo(() => {
+const useDeployment = Context.memo(() => {
     const state = new Map();
     return {
-        async lookup(deployment, options) {
-            if (state.has(deployment))
-                return state.get(deployment);
-            const { stackSdk, resolvedEnvironment } = await deployment.prepareSdkFor(options.stack, options.roleArn);
-            const toolkitInfo = await ToolkitInfo.lookup(resolvedEnvironment, stackSdk, options.toolkitStackName);
-            state.set(deployment, toolkitInfo);
-            return toolkitInfo;
+        async get(sdkProvider, options) {
+            if (!state.has(sdkProvider)) {
+                const deployment = new CloudFormationDeployments({ sdkProvider });
+                const { stackSdk, resolvedEnvironment, cloudFormationRoleArn } = await deployment.prepareSdkFor(options.stack, options.roleArn);
+                const toolkitInfo = await ToolkitInfo.lookup(resolvedEnvironment, stackSdk, options.toolkitStackName);
+                // Do a verification of the bootstrap stack version
+                await deployment.validateBootstrapStackVersion(options.stack.stackName, options.stack.requiresBootstrapStackVersion, options.stack.bootstrapStackVersionSsmParameter, toolkitInfo);
+                state.set(sdkProvider, {
+                    deployment,
+                    toolkitInfo,
+                    stackSdk,
+                    resolvedEnvironment,
+                    cloudFormationRoleArn,
+                });
+            }
+            return state.get(sdkProvider);
         }
     };
 });
+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 }).promise();
+        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.toolkitInfo, 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.toolkitInfo, options.sdk, options.overrideTemplate);
+    await publishAssets(legacyAssets.toManifest(stackArtifact.assembly.directory), options.sdkProvider, stackEnv, {
+        parallel: options.assetParallelism,
+    });
+    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,
+        },
+    };
+}

package/cdk/cloudformation-deployments.d.ts

@@ -290,6 +290,6 @@ export declare class CloudFormationDeployments {
     /**
      * Validate that the bootstrap stack has the right version for this stack
      */
-    private validateBootstrapStackVersion;
+    validateBootstrapStackVersion(stackName: string, requiresBootstrapStackVersion: number | undefined, bootstrapStackVersionSsmParameter: string | undefined, toolkitInfo: ToolkitInfo): Promise<void>;
 }
 export {};

package/cdk/deploy-stack.d.ts

@@ -1,5 +1,6 @@
 import * as cxapi from "@aws-cdk/cx-api";
 import { Tag } from "aws-cdk/lib/cdk-toolkit.js";
+import { AssetManifestBuilder } from "aws-cdk/lib/util/asset-manifest-builder.js";
 import { ISDK, SdkProvider } from "aws-cdk/lib/api/aws-auth/index.js";
 import { ToolkitInfo } from "aws-cdk/lib/api/toolkit-info.js";
 import { ResourcesToImport } from "aws-cdk/lib/api/util/cloudformation.js";
@@ -185,6 +186,20 @@ export interface ChangeSetDeploymentMethod {
     readonly changeSetName?: string;
 }
 export declare function deployStack(options: DeployStackOptions): Promise<DeployStackResult | undefined>;
+/**
+ * Prepares the body parameter for +CreateChangeSet+.
+ *
+ * If the template is small enough to be inlined into the API call, just return
+ * it immediately.
+ *
+ * Otherwise, add it to the asset manifest to get uploaded to the staging
+ * bucket and return its coordinates. If there is no staging bucket, an error
+ * is thrown.
+ *
+ * @param stack     the synthesized stack that provides the CloudFormation template
+ * @param toolkitInfo information about the toolkit stack
+ */
+export declare function makeBodyParameter(stack: cxapi.CloudFormationStackArtifact, resolvedEnvironment: cxapi.Environment, assetManifest: AssetManifestBuilder, toolkitInfo: ToolkitInfo, sdk: ISDK, overrideTemplate?: any): Promise<TemplateBodyParameter>;
 /**
  * Prepare a body parameter for CFN, performing the upload
  *

package/cdk/deploy-stack.js

@@ -340,7 +340,7 @@ class FullCloudFormationDeployment {
  * @param stack     the synthesized stack that provides the CloudFormation template
  * @param toolkitInfo information about the toolkit stack
  */
-async function makeBodyParameter(stack, resolvedEnvironment, assetManifest, toolkitInfo, sdk, overrideTemplate) {
+export async function makeBodyParameter(stack, resolvedEnvironment, assetManifest, toolkitInfo, sdk, overrideTemplate) {
     // If the template has already been uploaded to S3, just use it from there.
     if (stack.stackTemplateAssetObjectUrl && !overrideTemplate) {
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sst",
-  "version": "2.0.0-rc.38",
+  "version": "2.0.0-rc.39",
   "bin": {
     "sst": "cli/sst.js"
   },

package/sst.mjs

@@ -2120,11 +2120,26 @@ var init_cloudformation_deployments = __esm({
 // src/cdk/cloudformation-deployments-wrapper.ts
 var cloudformation_deployments_wrapper_exports = {};
 __export(cloudformation_deployments_wrapper_exports, {
-  publishAssets: () => publishAssets3
+  publishDeployAssets: () => publishDeployAssets
 });
+import { debug as debug3 } from "aws-cdk/lib/logging.js";
+import {
+  CloudFormationStack as CloudFormationStack3,
+  TemplateParameters as TemplateParameters2,
+  waitForStackDelete as waitForStackDelete2
+} from "aws-cdk/lib/api/util/cloudformation.js";
 import { ToolkitInfo as ToolkitInfo2 } from "aws-cdk/lib/api/toolkit-info.js";
-async function publishAssets3(deployment, options) {
-  const toolkitInfo = await useToolkitInfo().lookup(deployment, options);
+import { addMetadataAssetsToManifest as addMetadataAssetsToManifest2 } from "aws-cdk/lib/assets.js";
+import { publishAssets as publishAssets3 } from "aws-cdk/lib/util/asset-publishing.js";
+import { AssetManifestBuilder as AssetManifestBuilder2 } from "aws-cdk/lib/util/asset-manifest-builder.js";
+async function publishDeployAssets(sdkProvider, options) {
+  const {
+    deployment,
+    toolkitInfo,
+    stackSdk,
+    resolvedEnvironment,
+    cloudFormationRoleArn
+  } = await useDeployment().get(sdkProvider, options);
   await deployment.publishStackAssets(options.stack, toolkitInfo, {
     buildAssets: options.buildAssets ?? true,
     publishOptions: {
@@ -2132,26 +2147,130 @@ async function publishAssets3(deployment, options) {
       parallel: options.assetParallelism
     }
   });
+  return deployStack2({
+    stack: options.stack,
+    noMonitor: true,
+    resolvedEnvironment,
+    deployName: options.deployName,
+    notificationArns: options.notificationArns,
+    quiet: options.quiet,
+    sdk: stackSdk,
+    sdkProvider,
+    roleArn: cloudFormationRoleArn,
+    reuseAssets: options.reuseAssets,
+    toolkitInfo,
+    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
+  });
+}
+async function deployStack2(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 CloudFormationStack3.lookup(cfn, deployName);
+  if (cloudFormationStack.stackStatus.isCreationFailure) {
+    debug3(
+      `Found existing stack ${deployName} that had previously failed creation. Deleting it before attempting to re-create it.`
+    );
+    await cfn.deleteStack({ StackName: deployName }).promise();
+    const deletedStack = await waitForStackDelete2(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})`
+      );
+    }
+    cloudFormationStack = CloudFormationStack3.doesNotExist(cfn, deployName);
+  }
+  const legacyAssets = new AssetManifestBuilder2();
+  const assetParams = await addMetadataAssetsToManifest2(
+    stackArtifact,
+    legacyAssets,
+    options.toolkitInfo,
+    options.reuseAssets
+  );
+  const finalParameterValues = { ...options.parameters, ...assetParams };
+  const templateParams = TemplateParameters2.fromTemplate(
+    stackArtifact.template
+  );
+  const stackParams = options.usePreviousParameters ? templateParams.updateExisting(
+    finalParameterValues,
+    cloudFormationStack.parameters
+  ) : templateParams.supplyAll(finalParameterValues);
+  const bodyParameter = await makeBodyParameter(
+    stackArtifact,
+    options.resolvedEnvironment,
+    legacyAssets,
+    options.toolkitInfo,
+    options.sdk,
+    options.overrideTemplate
+  );
+  await publishAssets3(
+    legacyAssets.toManifest(stackArtifact.assembly.directory),
+    options.sdkProvider,
+    stackEnv,
+    {
+      parallel: options.assetParallelism
+    }
+  );
+  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
+    }
+  };
 }
-var useToolkitInfo;
+var useDeployment;
 var init_cloudformation_deployments_wrapper = __esm({
   "src/cdk/cloudformation-deployments-wrapper.ts"() {
     "use strict";
+    init_cloudformation_deployments();
+    init_deploy_stack();
     init_context();
-    useToolkitInfo = Context.memo(() => {
+    useDeployment = Context.memo(() => {
       const state2 = /* @__PURE__ */ new Map();
       return {
-        async lookup(deployment, options) {
-          if (state2.has(deployment))
-            return state2.get(deployment);
-          const { stackSdk, resolvedEnvironment } = await deployment.prepareSdkFor(options.stack, options.roleArn);
-          const toolkitInfo = await ToolkitInfo2.lookup(
-            resolvedEnvironment,
-            stackSdk,
-            options.toolkitStackName
-          );
-          state2.set(deployment, toolkitInfo);
-          return toolkitInfo;
+        async get(sdkProvider, options) {
+          if (!state2.has(sdkProvider)) {
+            const deployment = new CloudFormationDeployments({ sdkProvider });
+            const { stackSdk, resolvedEnvironment, cloudFormationRoleArn } = await deployment.prepareSdkFor(options.stack, options.roleArn);
+            const toolkitInfo = await ToolkitInfo2.lookup(
+              resolvedEnvironment,
+              stackSdk,
+              options.toolkitStackName
+            );
+            await deployment.validateBootstrapStackVersion(
+              options.stack.stackName,
+              options.stack.requiresBootstrapStackVersion,
+              options.stack.bootstrapStackVersionSsmParameter,
+              toolkitInfo
+            );
+            state2.set(sdkProvider, {
+              deployment,
+              toolkitInfo,
+              stackSdk,
+              resolvedEnvironment,
+              cloudFormationRoleArn
+            });
+          }
+          return state2.get(sdkProvider);
         }
       };
     });
@@ -2162,23 +2281,22 @@ var init_cloudformation_deployments_wrapper = __esm({
 async function publishAssets4(stacks) {
   Logger.debug("Publishing assets");
   const provider = await useAWSProvider();
-  const { CloudFormationDeployments: CloudFormationDeployments2 } = await Promise.resolve().then(() => (init_cloudformation_deployments(), cloudformation_deployments_exports));
-  const { publishAssets: publishAssets5 } = await Promise.resolve().then(() => (init_cloudformation_deployments_wrapper(), cloudformation_deployments_wrapper_exports));
-  const deployment = new CloudFormationDeployments2({
-    sdkProvider: provider
-  });
+  const { publishDeployAssets: publishDeployAssets2 } = await Promise.resolve().then(() => (init_cloudformation_deployments_wrapper(), cloudformation_deployments_wrapper_exports));
+  const results = {};
   for (const stack of stacks) {
-    await publishAssets5(
-      deployment,
+    const result = await publishDeployAssets2(
+      provider,
       {
         stack,
-        quiet: true,
+        quiet: false,
         deploymentMethod: {
           method: "direct"
         }
       }
     );
+    results[stack.stackName] = result;
   }
+  return results;
 }
 async function deployMany(stacks) {
   Logger.debug(

package/stacks/deploy.d.ts

@@ -1,6 +1,6 @@
 import type { CloudFormationStackArtifact } from "aws-cdk-lib/cx-api";
 import { StackDeploymentResult } from "./monitor.js";
-export declare function publishAssets(stacks: CloudFormationStackArtifact[]): Promise<void>;
+export declare function publishAssets(stacks: CloudFormationStackArtifact[]): Promise<Record<string, any>>;
 export declare function deployMany(stacks: CloudFormationStackArtifact[]): Promise<Record<string, {
     status: string;
     outputs: Record<string, string>;

package/stacks/deploy.js

@@ -3,23 +3,21 @@ import { useAWSProvider } from "../credentials.js";
 import { Logger } from "../logger.js";
 import { isFailed, monitor } from "./monitor.js";
 export async function publishAssets(stacks) {
-    // TODO: use memo in cloudformation-deployments.ts
     Logger.debug("Publishing assets");
     const provider = await useAWSProvider();
-    const { CloudFormationDeployments } = await import("../cdk/cloudformation-deployments.js");
-    const { publishAssets } = await import("../cdk/cloudformation-deployments-wrapper.js");
-    const deployment = new CloudFormationDeployments({
-        sdkProvider: provider,
-    });
+    const { publishDeployAssets } = await import("../cdk/cloudformation-deployments-wrapper.js");
+    const results = {};
     for (const stack of stacks) {
-        await publishAssets(deployment, {
+        const result = await publishDeployAssets(provider, {
             stack: stack,
-            quiet: true,
+            quiet: false,
             deploymentMethod: {
                 method: "direct",
             },
         });
+        results[stack.stackName] = result;
     }
+    return results;
 }
 export async function deployMany(stacks) {
     Logger.debug("Deploying stacks", stacks.map((s) => s.stackName));