sst 2.0.0-rc.25 → 2.0.0-rc.28

package/bootstrap.d.ts

@@ -1,6 +1,4 @@
-export declare const LATEST_VERSION = "3";
 export declare const useBootstrap: () => Promise<{
-    version: string | undefined;
-    bucket: string | undefined;
-    stack: string | undefined;
+    version: never;
+    bucket: never;
 }>;

package/bootstrap.js

@@ -1,7 +1,14 @@
-import { GetParametersCommand, SSMClient } from "@aws-sdk/client-ssm";
-import { Tags, Stack, RemovalPolicy, App } from "aws-cdk-lib";
+import url from "url";
+import path from "path";
+import { DescribeStacksCommand, CloudFormationClient, } from "@aws-sdk/client-cloudformation";
+import { Tags, Stack, RemovalPolicy, App, CfnOutput } from "aws-cdk-lib";
+import { Function, Runtime, Code } from "aws-cdk-lib/aws-lambda";
+import { SqsEventSource } from "aws-cdk-lib/aws-lambda-event-sources";
+import { PolicyStatement } from "aws-cdk-lib/aws-iam";
+import { Queue } from "aws-cdk-lib/aws-sqs";
+import { Rule } from "aws-cdk-lib/aws-events";
+import { SqsQueue } from "aws-cdk-lib/aws-events-targets";
 import { BlockPublicAccess, Bucket, BucketEncryption, } from "aws-cdk-lib/aws-s3";
-import { ParameterTier, StringParameter } from "aws-cdk-lib/aws-ssm";
 import { useProject } from "./project.js";
 import { createSpinner } from "./cli/spinner.js";
 import { Context } from "./context/context.js";
@@ -9,71 +16,121 @@ import { useAWSClient } from "./credentials.js";
 import { VisibleError } from "./error.js";
 import { Logger } from "./logger.js";
 import { Stacks } from "./stacks/index.js";
-const SSM_NAME_VERSION = `/sst/bootstrap/version`;
-const SSM_NAME_STACK_NAME = `/sst/bootstrap/stack-name`;
-const SSM_NAME_BUCKET_NAME = `/sst/bootstrap/bucket-name`;
-export const LATEST_VERSION = "3";
+const STACK_NAME = "SSTBootstrap";
+const OUTPUT_VERSION = "Version";
+const OUTPUT_BUCKET = "BucketName";
+const LATEST_VERSION = "4";
+const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 export const useBootstrap = Context.memo(async () => {
     Logger.debug("Initializing bootstrap context");
-    const ret = await ssm();
-    if (!ret.version ||
-        !ret.bucket ||
-        !ret.stack ||
-        ret.version !== LATEST_VERSION) {
+    let status = await loadBootstrapStatus();
+    if (!status || status.version !== LATEST_VERSION) {
         const project = useProject();
         const spinner = createSpinner("Deploying bootstrap stack, this only needs to happen once").start();
+        // Create bootstrap stack
         const app = new App();
-        const stack = new Stack(app, "SSTBootstrap", {
+        const stack = new Stack(app, STACK_NAME, {
             env: {
                 region: project.config.region,
             },
         });
+        // Add tags to stack
         const tags = {};
         for (const [key, value] of Object.entries(tags)) {
             Tags.of(app).add(key, value);
         }
+        // Create S3 bucket to store stacks metadata
         const bucket = new Bucket(stack, project.config.region, {
             encryption: BucketEncryption.S3_MANAGED,
             removalPolicy: RemovalPolicy.DESTROY,
             autoDeleteObjects: true,
             blockPublicAccess: BlockPublicAccess.BLOCK_ALL,
         });
-        new StringParameter(stack, SSM_NAME_VERSION, {
-            parameterName: SSM_NAME_VERSION,
-            stringValue: LATEST_VERSION,
-            tier: ParameterTier.STANDARD,
+        // Create Function and subscribe to CloudFormation events
+        const fn = new Function(stack, "MetadataHandler", {
+            code: Code.fromAsset(path.resolve(__dirname, "support/bootstrap-metadata-function")),
+            handler: "index.handler",
+            runtime: Runtime.NODEJS_16_X,
+            initialPolicy: [
+                new PolicyStatement({
+                    actions: ["cloudformation:DescribeStacks"],
+                    resources: ["*"],
+                }),
+                new PolicyStatement({
+                    actions: ["s3:PutObject", "s3:DeleteObject"],
+                    resources: [bucket.bucketArn + "/*"],
+                }),
+            ],
         });
-        new StringParameter(stack, SSM_NAME_STACK_NAME, {
-            parameterName: SSM_NAME_STACK_NAME,
-            stringValue: stack.stackName,
-            tier: ParameterTier.STANDARD,
-        });
-        new StringParameter(stack, SSM_NAME_BUCKET_NAME, {
-            parameterName: SSM_NAME_BUCKET_NAME,
-            stringValue: bucket.bucketName,
-            tier: ParameterTier.STANDARD,
+        const queue = new Queue(stack, "MetadataQueue");
+        fn.addEventSource(new SqsEventSource(queue));
+        const rule = new Rule(stack, "MetadataRule", {
+            eventPattern: {
+                source: ["aws.cloudformation"],
+                detailType: ["CloudFormation Stack Status Change"],
+                detail: {
+                    "status-details": {
+                        status: [
+                            "CREATE_COMPLETE",
+                            "UPDATE_COMPLETE",
+                            "UPDATE_ROLLBACK_COMPLETE",
+                            "ROLLBACK_COMPLETE",
+                            "DELETE_COMPLETE",
+                        ],
+                    }
+                }
+            }
         });
+        rule.addTarget(new SqsQueue(queue, {
+            retryAttempts: 10,
+        }));
+        // Create stack outputs to store bootstrap stack info
+        new CfnOutput(stack, OUTPUT_VERSION, { value: LATEST_VERSION });
+        new CfnOutput(stack, OUTPUT_BUCKET, { value: bucket.bucketName });
+        // Deploy bootstrap stack
         const asm = app.synth();
         const result = await Stacks.deploy(asm.stacks[0]);
         if (Stacks.isFailed(result.status)) {
             throw new VisibleError(`Failed to deploy bootstrap stack:\n${JSON.stringify(result.errors, null, 4)}`);
         }
         spinner.succeed();
-        return ssm();
+        // Fetch bootstrap status
+        status = await loadBootstrapStatus();
+        if (!status) {
+            throw new VisibleError("Failed to deploy bootstrap stack");
+        }
     }
-    Logger.debug("Loaded bootstrap info: ", JSON.stringify(ret));
-    return ret;
+    Logger.debug("Loaded bootstrap info: ", JSON.stringify(status));
+    return status;
 });
-async function ssm() {
-    const ssm = useAWSClient(SSMClient);
-    const result = await ssm.send(new GetParametersCommand({
-        Names: [SSM_NAME_VERSION, SSM_NAME_STACK_NAME, SSM_NAME_BUCKET_NAME],
-    }));
-    return {
-        version: result.Parameters.find((p) => p.Name === SSM_NAME_VERSION)?.Value,
-        bucket: result.Parameters.find((p) => p.Name === SSM_NAME_BUCKET_NAME)
-            ?.Value,
-        stack: result.Parameters.find((p) => p.Name === SSM_NAME_STACK_NAME)
-            ?.Value,
-    };
+async function loadBootstrapStatus() {
+    // Get bootstrap CloudFormation stack
+    const cf = useAWSClient(CloudFormationClient);
+    let result;
+    try {
+        result = await cf.send(new DescribeStacksCommand({
+            StackName: STACK_NAME,
+        }));
+    }
+    catch (e) {
+        if (e.Code === "ValidationError"
+            && e.message === `Stack with id ${STACK_NAME} does not exist`) {
+            return null;
+        }
+        throw e;
+    }
+    // Parse stack outputs
+    let version, bucket;
+    (result.Stacks[0].Outputs || []).forEach((o) => {
+        if (o.OutputKey === OUTPUT_VERSION) {
+            version = o.OutputValue;
+        }
+        else if (o.OutputKey === OUTPUT_BUCKET) {
+            bucket = o.OutputValue;
+        }
+    });
+    if (!version || !bucket) {
+        return null;
+    }
+    return { version, bucket };
 }

package/cli/commands/deploy.js

@@ -37,15 +37,20 @@ export const deploy = (program) => program.command("deploy [filter]", "Work on y
         return;
     }
     console.log(`Deploying ${bold(target.length + " stacks")} for stage ${blue(project.config.stage)}...`);
-    let component = undefined;
-    if (args.fullscreen) {
-        process.stdout.write("\x1b[?1049h");
-        component = render(React.createElement(DeploymentUI, { stacks: assembly.stacks.map((s) => s.stackName) }));
-    }
+    const cleanup = (() => {
+        if (args.fullscreen) {
+            process.stdout.write("\x1b[?1049h");
+            const component = render(React.createElement(DeploymentUI, { stacks: assembly.stacks.map((s) => s.stackName) }));
+            return () => {
+                component.unmount();
+                process.stdout.write("\x1b[?1049l");
+            };
+        }
+        const spinner = createSpinner("Deploying stacks");
+        return () => spinner.succeed();
+    })();
     const results = await Stacks.deployMany(target);
-    if (component)
-        component.unmount();
-    process.stdout.write("\x1b[?1049l");
+    cleanup();
     printDeploymentResults(results);
     if (Object.values(results).some((stack) => Stacks.isFailed(stack.status)))
         process.exit(1);

package/cli/commands/dev.js

@@ -108,15 +108,20 @@ export const dev = (program) => program.command(["start", "dev"], "Work on your
             const assembly = pending;
             const nextChecksum = await checksum(assembly.directory);
             pending = undefined;
-            let component = undefined;
-            if (args.fullscreen) {
-                process.stdout.write("\x1b[?1049h");
-                component = render(React.createElement(DeploymentUI, { stacks: assembly.stacks.map((s) => s.stackName) }));
-            }
+            const cleanup = (() => {
+                if (args.fullscreen) {
+                    process.stdout.write("\x1b[?1049h");
+                    const component = render(React.createElement(DeploymentUI, { stacks: assembly.stacks.map((s) => s.stackName) }));
+                    return () => {
+                        component.unmount();
+                        process.stdout.write("\x1b[?1049l");
+                    };
+                }
+                const spinner = createSpinner("Deploying stacks");
+                return () => spinner.succeed();
+            })();
             const results = await Stacks.deployMany(assembly.stacks);
-            if (component)
-                component.unmount();
-            process.stdout.write("\x1b[?1049l");
+            cleanup();
             lastDeployed = nextChecksum;
             printDeploymentResults(results);
             const keys = await SiteEnv.keys();

package/cli/commands/remove.d.ts

@@ -8,6 +8,8 @@ export declare const remove: (program: Program) => import("yargs").Argv<{
     region: string | undefined;
 } & {
     from: string | undefined;
+} & {
+    fullscreen: boolean;
 } & {
     filter: string | undefined;
 }>;

package/cli/commands/remove.js

@@ -1,6 +1,12 @@
+import { createSpinner } from "../spinner.js";
 import { printDeploymentResults } from "../ui/deploy.js";
 export const remove = (program) => program.command("remove [filter]", "Remove all stacks for this app", (yargs) => yargs
     .option("from", { type: "string" })
+    .option("fullscreen", {
+    type: "boolean",
+    describe: "Disable full screen UI",
+    default: true,
+})
     .positional("filter", { type: "string" }), async (args) => {
     const React = await import("react");
     const { CloudAssembly } = await import("aws-cdk-lib/cx-api");
@@ -28,11 +34,22 @@ export const remove = (program) => program.command("remove [filter]", "Remove al
         process.exit(1);
     }
     console.log(`Removing ${bold(target.length + " stacks")} for stage ${blue(project.config.stage)}...`);
-    process.stdout.write("\x1b[?1049h");
-    const component = render(React.createElement(DeploymentUI, { stacks: target.map((s) => s.stackName) }));
+    const cleanup = (() => {
+        if (args.fullscreen) {
+            process.stdout.write("\x1b[?1049h");
+            const component = render(React.createElement(DeploymentUI, { stacks: assembly.stacks.map((s) => s.stackName) }));
+            return () => {
+                component.unmount();
+                process.stdout.write("\x1b[?1049l");
+            };
+        }
+        const spinner = createSpinner("Removing stacks");
+        return () => spinner.succeed();
+    })();
     const results = await Stacks.removeMany(target);
-    component.unmount();
-    process.stdout.write("\x1b[?1049l");
+    cleanup();
     printDeploymentResults(results);
+    if (Object.values(results).some((stack) => Stacks.isFailed(stack.status)))
+        process.exit(1);
     process.exit(0);
 });

package/cli/ui/deploy.js

@@ -76,7 +76,10 @@ export const DeploymentUI = (props) => {
         React.createElement(Text, null,
             "Deploying ",
             React.createElement(Text, { color: "bold" }, props.stacks.length),
-            " stacks for stage ",
+            " stack",
+            props.stacks.length > 1 && "s",
+            " for stage",
+            " ",
             React.createElement(Text, { color: "blue" }, useProject().config.stage)),
         Object.entries(stacks).map(([stackID, status]) => {
             return (React.createElement(React.Fragment, { key: stackID },
@@ -106,9 +109,9 @@ export const DeploymentUI = (props) => {
 };
 export function printDeploymentResults(results) {
     console.log();
-    console.log(`----------------------------`);
-    console.log(`| Stack deployment results |`);
-    console.log(`----------------------------`);
+    console.log(`-----------`);
+    console.log(`| Summary |`);
+    console.log(`-----------`);
     for (const [stack, result] of Object.entries(results)) {
         const icon = (() => {
             if (Stacks.isSuccess(result.status))
@@ -122,6 +125,8 @@ export function printDeploymentResults(results) {
                 return false;
             if (key.includes("SstSiteEnv"))
                 return false;
+            if (key === "SstMetadata")
+                return false;
             return true;
         });
         if (outputs.length > 0) {

package/constructs/App.js

@@ -304,7 +304,15 @@ export class App extends cdk.App {
         for (const child of this.node.children) {
             if (child instanceof Stack) {
                 const stackName = child.node.id;
-                child.setStackMetadata(byStack[stackName] || []);
+                child.addOutputs({
+                    SstMetadata: JSON.stringify({
+                        app: this.name,
+                        stage: this.stage,
+                        version: useProject().version,
+                        bootstrapBucket: this.bootstrap.bucket,
+                        metadata: byStack[stackName] || [],
+                    }),
+                });
             }
         }
     }

package/constructs/Stack.d.ts

@@ -32,7 +32,6 @@ export declare class Stack extends cdk.Stack {
      * @internal
      */
     readonly customResourceHandler: lambda.Function;
-    private readonly metadata;
     constructor(scope: Construct, id: string, props?: StackProps);
     /**
      * The default function props to be applied to all the Lambda functions in the stack.
@@ -129,9 +128,8 @@ export declare class Stack extends cdk.Stack {
      * ```
      */
     addOutputs(outputs: Record<string, string | cdk.CfnOutputProps>): void;
-    setStackMetadata(metadata: any): void;
     private createCustomResourceHandler;
-    private createStackMetadataResource;
+    private createSecretsMigrationResource;
     private static checkForPropsIsConstruct;
     private static checkForEnvInProps;
 }

package/constructs/Stack.js

@@ -5,10 +5,8 @@ import * as iam from "aws-cdk-lib/aws-iam";
 import * as lambda from "aws-cdk-lib/aws-lambda";
 import { Function as Fn } from "./Function.js";
 import { isConstruct } from "./Construct.js";
-import { createRequire } from "module";
 import { useApp } from "./context.js";
 import { useProject } from "../project.js";
-const require = createRequire(import.meta.url);
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
 /**
  * The Stack construct extends cdk.Stack. It automatically prefixes the stack names with the stage and app name to ensure that they can be deployed to multiple regions in the same AWS account. It also ensure that the stack uses the same AWS profile and region as the app. They're defined using functions that return resources that can be imported by other stacks.
@@ -36,7 +34,6 @@ export class Stack extends cdk.Stack {
      * @internal
      */
     customResourceHandler;
-    metadata;
     constructor(scope, id, props) {
         const root = scope.node.root;
         const stackId = root.logicalPrefixedName(id);
@@ -51,15 +48,10 @@ export class Stack extends cdk.Stack {
         });
         this.stage = root.stage;
         this.defaultFunctionProps = root.defaultFunctionProps.map((dfp) => typeof dfp === "function" ? dfp(this) : dfp);
-        // We created the Metadata resource first with empty metadata, and on
-        // app synthesis we'll update it with the actual metadata.
-        // We do this two step process because we call the "Template.fromStack"
-        // method in the tests. And the call triggers an app synethsis. And we
-        // end up synthesize an app multiple times. If we created the Metadata
-        // resource on app synth, the tests would fail because the resource
-        // would already exist.
+        // Create a custom resource handler per stack. This handler will
+        // be used by all the custom resources in the stack.
         this.customResourceHandler = this.createCustomResourceHandler();
-        this.metadata = this.createStackMetadataResource();
+        this.createSecretsMigrationResource();
     }
     /**
      * The default function props to be applied to all the Lambda functions in the stack.
@@ -200,9 +192,6 @@ export class Stack extends cdk.Stack {
             }
         });
     }
-    setStackMetadata(metadata) {
-        this.metadata.node.defaultChild.addPropertyOverride("Metadata", metadata);
-    }
     createCustomResourceHandler() {
         return new lambda.Function(this, "CustomResourceHandler", {
             code: lambda.Code.fromAsset(path.join(__dirname, "../support/custom-resources/"), {
@@ -214,14 +203,9 @@ export class Stack extends cdk.Stack {
             memorySize: 1024,
         });
     }
-    createStackMetadataResource() {
+    createSecretsMigrationResource() {
         const app = useApp();
-        // Create execution policy
-        this.customResourceHandler.addToRolePolicy(new iam.PolicyStatement({
-            actions: ["s3:PutObject", "s3:DeleteObject"],
-            resources: [`arn:aws:s3:::${app.bootstrap.bucket}/*`],
-        }));
-        // Temporary: Add permissions to migrate SSM paths for secrets (piggybacking on the stack metadata custom resource handler)
+        // Add permissions to migrate SSM paths for secrets
         this.customResourceHandler.addToRolePolicy(new iam.PolicyStatement({
             actions: ["ssm:GetParametersByPath", "ssm:PutParameter"],
             resources: [
@@ -229,18 +213,13 @@ export class Stack extends cdk.Stack {
                 `arn:aws:ssm:${app.region}:${app.account}:parameter/sst/${app.name}/.fallback/*`,
             ],
         }));
-        return new cdk.CustomResource(this, "StackMetadata", {
+        new cdk.CustomResource(this, "SecretsMigration", {
             serviceToken: this.customResourceHandler.functionArn,
-            resourceType: "Custom::StackMetadata",
+            resourceType: "Custom::SecretsMigration",
             properties: {
                 App: app.name,
                 Stage: this.stage,
-                Stack: this.stackName,
                 SSTVersion: useProject().version,
-                BootstrapBucketName: app.bootstrap.bucket,
-                ForceUpdate: process.env.SST_FORCE_UPDATE_METADATA
-                    ? Date.now().toString()
-                    : undefined,
             },
         });
     }

package/package.json

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