sst 2.0.0-rc.41 → 2.0.0-rc.42

package/bootstrap.js

@@ -31,6 +31,7 @@ export async function initBootstrap() {
         loadCDKStatus(),
         loadSSTStatus(),
     ]);
+    Logger.debug("Loaded bootstrap status");
     const needToBootstrapCDK = !cdkStatus;
     const needToBootstrapSST = !sstStatus || sstStatus.version !== LATEST_VERSION;
     if (needToBootstrapCDK || needToBootstrapSST) {
@@ -56,16 +57,15 @@ async function loadCDKStatus() {
         const { Stacks: stacks } = await client.send(new DescribeStacksCommand({
             StackName: "CDKToolkit",
         }));
-        if (stacks && stacks.length > 0 && [
-            "CREATE_COMPLETE",
-            "UPDATE_COMPLETE",
-        ].includes(stacks[0].StackStatus)) {
+        if (stacks &&
+            stacks.length > 0 &&
+            ["CREATE_COMPLETE", "UPDATE_COMPLETE"].includes(stacks[0].StackStatus)) {
             return true;
         }
     }
     catch (e) {
-        if (e.name === "ValidationError"
-            && e.message === "Stack with id CDKToolkit does not exist") {
+        if (e.name === "ValidationError" &&
+            e.message === "Stack with id CDKToolkit does not exist") {
             return false;
         }
         else {

package/cli/colors.d.ts

@@ -1,6 +1,8 @@
 import chalk from "chalk";
+declare let last: "line" | "gap";
 export declare const Colors: {
     line: (message?: any, ...optionalParams: any[]) => void;
+    mode(input: typeof last): void;
     gap(): void;
     hex: (color: string) => chalk.Chalk;
     primary: chalk.Chalk;
@@ -23,3 +25,4 @@ export declare const Colors: {
     };
     prefix: string;
 };
+export {};

package/cli/colors.js

@@ -5,6 +5,9 @@ export const Colors = {
         last = "line";
         console.log(message, ...optionalParams);
     },
+    mode(input) {
+        last = input;
+    },
     gap() {
         if (last === "line") {
             last = "gap";

package/cli/commands/dev.d.ts

@@ -10,4 +10,6 @@ export declare const dev: (program: Program) => import("yargs").Argv<{
     verbose: boolean | undefined;
 } & {
     role: string | undefined;
+} & {
+    "increase-timeout": boolean | undefined;
 }>;

package/cli/commands/dev.js

@@ -1,7 +1,10 @@
 import chalk from "chalk";
 import { Colors } from "../colors.js";
 import { printHeader } from "../ui/header.js";
-export const dev = (program) => program.command(["dev", "start"], "Work on your app locally", (yargs) => yargs, async (args) => {
+export const dev = (program) => program.command(["dev", "start"], "Work on your app locally", (yargs) => yargs.option("increase-timeout", {
+    type: "boolean",
+    description: "Increase function timeout",
+}), async (args) => {
     const { useRuntimeWorkers } = await import("../../runtime/workers.js");
     const { useIOTBridge } = await import("../../runtime/iot.js");
     const { useRuntimeServer } = await import("../../runtime/server.js");
@@ -62,19 +65,16 @@ export const dev = (program) => program.command(["dev", "start"], "Work on your
                 Colors.line(prefix(evt.properties.requestID), Colors.dim(("+" + (Date.now() - started) + "ms").padEnd(7)), Colors.dim(line));
             }
         });
-        /*
         bus.subscribe("function.build.success", async (evt) => {
-          console.log(
-            bold(gray(`Built   `)),
-            useFunctions().fromID(evt.properties.functionID).handler!
-          );
+            Colors.line(Colors.dim(Colors.prefix, "Built", useFunctions().fromID(evt.properties.functionID).handler));
         });
-        */
         bus.subscribe("function.build.failed", async (evt) => {
-            Colors.line(Colors.danger(Colors.prefix), useFunctions().fromID(evt.properties.functionID).handler);
+            Colors.gap();
+            Colors.line(Colors.danger("✖ "), "Build failed", useFunctions().fromID(evt.properties.functionID).handler);
             for (const line of evt.properties.errors) {
-                Colors.line(Colors.danger(Colors.prefix), line);
+                Colors.line("  ", line);
             }
+            Colors.gap();
         });
         bus.subscribe("function.success", async (evt) => {
             // stdout logs sometimes come in after
@@ -88,7 +88,7 @@ export const dev = (program) => program.command(["dev", "start"], "Work on your
             setTimeout(() => {
                 Colors.line(prefix(evt.properties.requestID), Colors.danger.bold("Error:"), Colors.danger.bold(evt.properties.errorMessage));
                 for (const line of evt.properties.trace || []) {
-                    Colors.line(prefix(evt.properties.requestID), `${dim(line)}`);
+                    Colors.line("  ", `${dim(line)}`);
                 }
                 end(evt.properties.requestID);
             }, 100);
@@ -129,9 +129,11 @@ export const dev = (program) => program.command(["dev", "start"], "Work on your
                 if (!lastDeployed) {
                     spinner.stop();
                     spinner.clear();
+                    Colors.mode("gap");
                 }
                 else {
                     spinner.succeed(` Stacks built!`);
+                    Colors.mode("gap");
                 }
                 pending = assembly;
                 if (lastDeployed)

package/cli/commands/plugins/pothos.js

@@ -6,6 +6,7 @@ import { exec } from "child_process";
 import { promisify } from "util";
 const execAsync = promisify(exec);
 import path from "path";
+import { Colors } from "../../colors.js";
 export const usePothosBuilder = Context.memo(() => {
     let routes = [];
     const bus = useBus();
@@ -17,11 +18,14 @@ export const usePothosBuilder = Context.memo(() => {
             await fs.writeFile(route.output, schema);
             // bus.publish("pothos.extracted", { file: route.output });
             await Promise.all(route.commands.map((cmd) => execAsync(cmd)));
-            console.log("Done building pothos schema");
+            Colors.line(Colors.prefix);
+            Colors.line(Colors.success(`✔`), " Extracted pothos schema");
         }
         catch (ex) {
-            console.error("Failed to extract schema from pothos");
-            console.error(ex);
+            Colors.line(Colors.danger(`✖`), " Failed to extract schema from pothos:");
+            for (let line of ex.message.split("\n")) {
+                console.log(`  `, line);
+            }
         }
     }
     bus.subscribe("file.changed", async (evt) => {

package/cli/commands/update-mod.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="yargs" />
+import type { Program } from "../program.js";
+export declare const updateMod: (program: Program) => import("yargs").Argv<{
+    stage: string | undefined;
+} & {
+    profile: string | undefined;
+} & {
+    region: string | undefined;
+} & {
+    verbose: boolean | undefined;
+} & {
+    role: string | undefined;
+} & {
+    transform: string;
+}>;

package/cli/commands/update-mod.js

@@ -0,0 +1,53 @@
+export const updateMod = (program) => program.command("update-mod <transform>", "Transforms your SST app", (yargs) => yargs.positional("transform", {
+    type: "string",
+    describe: "Name of the transform",
+    demandOption: true,
+}), async (args) => {
+    const { green } = await import("colorette");
+    if (args.transform === "resource-binding-secrets") {
+        await handleSecretsMigration();
+    }
+    console.log(green(`Update transform "${args.transform}" has been applied successfully!`));
+});
+async function handleSecretsMigration() {
+    const { useProject } = await import("../../project.js");
+    const { useAWSClient } = await import("../../credentials.js");
+    const { SSMClient, GetParametersByPathCommand, PutParameterCommand } = await import("@aws-sdk/client-ssm");
+    const project = useProject();
+    const { name: app, stage } = project.config;
+    const ssm = useAWSClient(SSMClient);
+    async function* getAllPrametersByPath(prefix) {
+        let token;
+        while (true) {
+            const results = await ssm.send(new GetParametersByPathCommand({
+                Path: prefix,
+                WithDecryption: true,
+                Recursive: true,
+                NextToken: token,
+            }));
+            yield* results.Parameters || [];
+            if (!results.NextToken)
+                break;
+            token = results.NextToken;
+        }
+    }
+    async function migrateSecretsSSMPath(stage) {
+        const oldPrefix = `/sst/${app}/${stage}/secrets/`;
+        const newPrefix = `/sst/${app}/${stage}/Secret/`;
+        for await (const secret of getAllPrametersByPath(oldPrefix)) {
+            const name = secret.Name.split("/")[5];
+            // Do not migrate SST Auth secrets b/c they are no longer secrets in v1.16.
+            if (name === "SST_AUTH_PRIVATE" || name === "SST_AUTH_PUBLIC") {
+                continue;
+            }
+            await ssm.send(new PutParameterCommand({
+                Name: `${newPrefix}${name}/value`,
+                Value: secret.Value,
+                Type: secret.Type,
+                Overwrite: true,
+            }));
+        }
+    }
+    await migrateSecretsSSMPath(stage);
+    await migrateSecretsSSMPath(".fallback");
+}

package/cli/program.js

@@ -42,7 +42,7 @@ export const program = yargs(hideBin(process.argv))
     .fail((_, error, yargs) => {
     if (!error) {
         yargs.showHelp();
-        return;
+        process.exit(1);
     }
     throw error;
 });

package/cli/spinner.js

@@ -1,5 +1,6 @@
 import { Context } from "../context/context.js";
 import ora from "ora";
+import { Colors } from "./colors.js";
 export const useSpinners = Context.memo(() => {
     const spinners = [];
     return spinners;
@@ -8,5 +9,6 @@ export function createSpinner(options) {
     const spinners = useSpinners();
     const next = ora(options);
     spinners.push(next);
+    Colors.mode("line");
     return next;
 }

package/cli/sst.js

@@ -15,6 +15,7 @@ import { remove } from "./commands/remove.js";
 import { consoleCommand } from "./commands/console.js";
 import { secrets } from "./commands/secrets/secrets.js";
 import { update } from "./commands/update.js";
+import { updateMod } from "./commands/update-mod.js";
 import { diff } from "./commands/diff.js";
 dev(program);
 deploy(program);
@@ -24,6 +25,7 @@ env(program);
 secrets(program);
 remove(program);
 update(program);
+updateMod(program);
 consoleCommand(program);
 diff(program);
 process.removeAllListeners("uncaughtException");

package/cli/ui/deploy.js

@@ -7,31 +7,17 @@ import { Colors } from "../colors.js";
 // @ts-ignore
 const { default: Spinner } = inkSpinner;
 export const DeploymentUI = (props) => {
-    const [stacks, setStacks] = useState(Object.fromEntries(props.stacks.map((s) => [s, ""])));
     const [resources, setResources] = useState({});
-    const [resources2, setResources2] = useState({});
     useEffect(() => {
         Colors.gap();
         Colors.line(`${Colors.primary(`➜`)}  ${Colors.bold(`Deploying...`)}`);
         Colors.gap();
         const bus = useBus();
-        const update = bus.subscribe("stack.updated", (payload) => {
-            setStacks((prev) => ({
-                ...prev,
-                [payload.properties.stackID]: "",
-            }));
-        });
-        const status = bus.subscribe("stack.status", (payload) => {
-            setStacks((prev) => ({
-                ...prev,
-                [payload.properties.stackID]: payload.properties.status,
-            }));
-        });
         const event = bus.subscribe("stack.event", (payload) => {
             const { event } = payload.properties;
             if (event.ResourceType === "AWS::CloudFormation::Stack")
                 return;
-            setResources2((previous) => {
+            setResources((previous) => {
                 if (Stacks.isFinal(event.ResourceStatus)) {
                     Colors.line(Colors.warning(Colors.prefix), Colors.dim(`${event.StackName} ${event.ResourceType} ${event.LogicalResourceId}`), Stacks.isFailed(event.ResourceStatus)
                         ? Colors.danger(event.ResourceStatus)
@@ -47,8 +33,6 @@ export const DeploymentUI = (props) => {
         });
         return () => {
             bus.unsubscribe(event);
-            bus.unsubscribe(update);
-            bus.unsubscribe(status);
         };
     }, []);
     function color(status) {
@@ -59,7 +43,7 @@ export const DeploymentUI = (props) => {
         return "yellow";
     }
     return (React.createElement(Box, { flexDirection: "column" },
-        Object.entries(resources2).map(([_, evt]) => {
+        Object.entries(resources).map(([_, evt]) => {
             return (React.createElement(Box, { key: evt.LogicalResourceId },
                 React.createElement(Text, null,
                     React.createElement(Spinner, null),
@@ -72,7 +56,11 @@ export const DeploymentUI = (props) => {
                     " "),
                 React.createElement(Text, { color: color(evt.ResourceStatus || "") }, evt.ResourceStatus)));
         }),
-        React.createElement(Box, null)));
+        Object.entries(resources).length === 0 && (React.createElement(Box, null,
+            React.createElement(Text, null,
+                React.createElement(Spinner, null),
+                "  ",
+                React.createElement(Text, { dimColor: true }, "Waiting for changes"))))));
 };
 export function printDeploymentResults(assembly, results) {
     Colors.gap();

package/constructs/Stack.d.ts

@@ -129,7 +129,6 @@ export declare class Stack extends cdk.Stack {
      */
     addOutputs(outputs: Record<string, string | cdk.CfnOutputProps>): void;
     private createCustomResourceHandler;
-    private createSecretsMigrationResource;
     private static checkForPropsIsConstruct;
     private static checkForEnvInProps;
 }

package/constructs/Stack.js

@@ -1,12 +1,9 @@
 import url from "url";
 import * as path from "path";
 import * as cdk from "aws-cdk-lib";
-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 { useApp } from "./context.js";
-import { useProject } from "../project.js";
 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.
@@ -51,7 +48,6 @@ export class Stack extends cdk.Stack {
         // 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.createSecretsMigrationResource();
     }
     /**
      * The default function props to be applied to all the Lambda functions in the stack.
@@ -203,26 +199,6 @@ export class Stack extends cdk.Stack {
             memorySize: 1024,
         });
     }
-    createSecretsMigrationResource() {
-        const app = useApp();
-        // Add permissions to migrate SSM paths for secrets
-        this.customResourceHandler.addToRolePolicy(new iam.PolicyStatement({
-            actions: ["ssm:GetParametersByPath", "ssm:PutParameter", "sns:Publish"],
-            resources: [
-                `arn:${this.partition}:ssm:${app.region}:${app.account}:parameter/sst/${app.name}/${app.stage}/*`,
-                `arn:${this.partition}:ssm:${app.region}:${app.account}:parameter/sst/${app.name}/.fallback/*`,
-            ],
-        }));
-        new cdk.CustomResource(this, "SecretsMigration", {
-            serviceToken: this.customResourceHandler.functionArn,
-            resourceType: "Custom::SecretsMigration",
-            properties: {
-                App: app.name,
-                Stage: this.stage,
-                SSTVersion: useProject().version,
-            },
-        });
-    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     static checkForPropsIsConstruct(id, props) {
         // If a construct is passed in as stack props, let's detect it and throw a

package/package.json

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

package/runtime/handlers/node.js

@@ -10,6 +10,7 @@ import { useRuntimeHandlers } from "../handlers.js";
 import { useRuntimeWorkers } from "../workers.js";
 import { Context } from "../../context/context.js";
 import { VisibleError } from "../../error.js";
+import { Colors } from "../../cli/colors.js";
 export const useNodeHandler = Context.memo(async () => {
     const workers = await useRuntimeWorkers();
     const handlers = useRuntimeHandlers();
@@ -102,6 +103,7 @@ export const useNodeHandler = Context.memo(async () => {
                 ],
                 keepNames: true,
                 bundle: true,
+                logLevel: "silent",
                 metafile: true,
                 ...(isESM
                     ? {
@@ -130,47 +132,60 @@ export const useNodeHandler = Context.memo(async () => {
                 minify: nodejs.minify,
                 ...override,
             };
-            const result = await esbuild.build(options);
-            // Install node_modules
-            if (options.external?.length) {
-                async function find(dir, target) {
-                    if (dir === "/")
-                        throw new VisibleError("Could not find a package.json file");
-                    if (await fs
-                        .access(path.join(dir, target))
-                        .then(() => true)
-                        .catch(() => false))
-                        return dir;
-                    return find(path.join(dir, ".."), target);
-                }
-                if (input.mode === "deploy" && nodejs.install) {
-                    const src = await find(parsed.dir, "package.json");
-                    const json = JSON.parse(await fs
-                        .readFile(path.join(src, "package.json"))
-                        .then((x) => x.toString()));
-                    fs.writeFile(path.join(input.out, "package.json"), JSON.stringify({
-                        dependencies: Object.fromEntries(nodejs.install?.map((x) => [x, json.dependencies?.[x] || "*"])),
-                    }));
-                    await new Promise((resolve) => {
-                        const process = exec("npm install", {
-                            cwd: input.out,
+            try {
+                const result = await esbuild.build(options);
+                // Install node_modules
+                if (options.external?.length) {
+                    async function find(dir, target) {
+                        if (dir === "/")
+                            throw new VisibleError("Could not find a package.json file");
+                        if (await fs
+                            .access(path.join(dir, target))
+                            .then(() => true)
+                            .catch(() => false))
+                            return dir;
+                        return find(path.join(dir, ".."), target);
+                    }
+                    if (input.mode === "deploy" && nodejs.install) {
+                        const src = await find(parsed.dir, "package.json");
+                        const json = JSON.parse(await fs
+                            .readFile(path.join(src, "package.json"))
+                            .then((x) => x.toString()));
+                        fs.writeFile(path.join(input.out, "package.json"), JSON.stringify({
+                            dependencies: Object.fromEntries(nodejs.install?.map((x) => [x, json.dependencies?.[x] || "*"])),
+                        }));
+                        await new Promise((resolve) => {
+                            const process = exec("npm install", {
+                                cwd: input.out,
+                            });
+                            process.on("exit", () => resolve());
                         });
-                        process.on("exit", () => resolve());
-                    });
-                }
-                if (input.mode === "start") {
-                    const dir = path.join(await find(parsed.dir, "package.json"), "node_modules");
-                    try {
-                        await fs.symlink(path.resolve(dir), path.resolve(path.join(input.out, "node_modules")), "dir");
                     }
-                    catch { }
+                    if (input.mode === "start") {
+                        const dir = path.join(await find(parsed.dir, "package.json"), "node_modules");
+                        try {
+                            await fs.symlink(path.resolve(dir), path.resolve(path.join(input.out, "node_modules")), "dir");
+                        }
+                        catch { }
+                    }
                 }
+                cache[input.functionID] = result;
+                return {
+                    type: "success",
+                    handler,
+                };
+            }
+            catch (ex) {
+                const result = ex;
+                return {
+                    type: "error",
+                    errors: result.errors.flatMap((x) => [
+                        Colors.bold(x.text),
+                        x.location?.file || "",
+                        Colors.dim(x.location?.line, "│", x.location?.lineText),
+                    ]),
+                };
             }
-            cache[input.functionID] = result;
-            return {
-                type: "success",
-                handler,
-            };
         },
     });
 });