sst 2.0.0-rc.24 → 2.0.0-rc.26

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: undefined;
+    bucket: undefined;
 }>;

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,103 @@ 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();
+    const ret = await loadBootstrapStatus();
     if (!ret.version ||
         !ret.bucket ||
-        !ret.stack ||
         ret.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 });
         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();
+        return loadBootstrapStatus();
     }
     Logger.debug("Loaded bootstrap info: ", JSON.stringify(ret));
     return ret;
 });
-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],
+async function loadBootstrapStatus() {
+    const cf = useAWSClient(CloudFormationClient);
+    const result = await cf.send(new DescribeStacksCommand({
+        StackName: STACK_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,
-    };
+    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;
+        }
+    });
+    return { version, bucket };
 }

package/cli/ui/deploy.js

@@ -122,6 +122,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.24",
+  "version": "2.0.0-rc.26",
   "bin": {
     "sst": "cli/sst.js"
   },

package/site-env.js

@@ -37,7 +37,7 @@ export async function writeValues(input) {
     await fs.promises.writeFile(file, JSON.stringify(input));
 }
 export function append(input) {
-    input.path = path.join(useProject().paths.root, input.path);
+    input.path = path.resolve(useProject().paths.root, input.path);
     fs.appendFileSync(keysFile(), JSON.stringify(input) + "\n");
 }
 export function reset() {