sst 2.0.0-rc.9 → 2.0.1

package/cli/commands/diff.js

@@ -0,0 +1,61 @@
+import { stackNameToId } from "../ui/stack.js";
+export const diff = (program) => program.command("diff", "Compare your app with what is deployed on AWS", (yargs) => yargs.option("dev", {
+    type: "boolean",
+    describe: "Compare in dev mode",
+}), async (args) => {
+    const { useProject } = await import("../../project.js");
+    const { Stacks } = await import("../../stacks/index.js");
+    const { useAWSClient } = await import("../../credentials.js");
+    const { CloudFormationClient, GetTemplateCommand } = await import("@aws-sdk/client-cloudformation");
+    const { createSpinner } = await import("../spinner.js");
+    const { green } = await import("colorette");
+    const { Colors } = await import("../colors.js");
+    // Build app
+    const project = useProject();
+    const assembly = await Stacks.synth({
+        fn: project.stacks,
+        mode: args.dev ? "dev" : "deploy",
+    });
+    // Diff each stack
+    let changesAcc = 0;
+    let changedStacks = 0;
+    const cfn = useAWSClient(CloudFormationClient);
+    for (const stack of assembly.stacks) {
+        const spinner = createSpinner(`${stack.stackName}: Checking for changes...`);
+        // get old template
+        const response = await cfn.send(new GetTemplateCommand({
+            StackName: stack.stackName,
+        }));
+        const oldTemplate = JSON.parse(response.TemplateBody);
+        // generate diff
+        const { count, diff } = await Stacks.diff(stack, oldTemplate);
+        spinner.clear();
+        // print diff result
+        if (count === 0) {
+            Colors.line(`➜  ${Colors.dim.bold(stackNameToId(stack.stackName) + ":")} No changes`);
+            Colors.gap();
+        }
+        else if (count === 1) {
+            Colors.line(`➜  ${Colors.dim.bold(stackNameToId(stack.stackName) + ":")} ${count} change`);
+            Colors.gap();
+            console.log(diff);
+            changesAcc += count;
+            changedStacks++;
+        }
+        else {
+            Colors.line(`➜  ${Colors.dim.bold(stackNameToId(stack.stackName) + ":")} ${count} changes`);
+            Colors.gap();
+            console.log(diff);
+            changesAcc += count;
+            changedStacks++;
+        }
+    }
+    // Handle no changes
+    if (changedStacks === 0) {
+        Colors.line(Colors.success(`✔`), Colors.bold(" Diff:"), "No changes");
+    }
+    else {
+        Colors.line(Colors.success(`✔`), Colors.bold(" Diff:"), changesAcc === 1 ? "1 change found in" : `${changesAcc} changes in`, changedStacks === 1 ? "1 stack" : `${changedStacks} stacks`);
+    }
+    process.exit(0);
+});

package/cli/commands/env.d.ts

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

package/cli/commands/env.js

@@ -1,30 +1,29 @@
-import { useProject } from "../../app.js";
-import { createSpinner } from "../spinner.js";
-import fs from "fs/promises";
-import path from "path";
-import { SiteEnv } from "../../site-env.js";
-import { spawnSync } from "child_process";
-export const env = (program) => program.command("env <command>", "description", (yargs) => yargs.positional("command", {
+export const env = (program) => program.command("env <command>", "Load environment variables and start your frontend", (yargs) => yargs
+    .positional("command", {
     type: "string",
-    describe: "Command to run with environment variabels loaded",
+    describe: "The command to start your frontend",
     demandOption: true,
-}), async (args) => {
-    const project = useProject();
-    const spinner = createSpinner("Waiting for SST to start").start();
+})
+    .example(`sst env "next dev"`, "Start Next.js with your environment variables")
+    .example(`sst env "vite dev"`, "Start Vite with your environment variables"), async (args) => {
+    const { createSpinner } = await import("../spinner.js");
+    const fs = await import("fs/promises");
+    const { SiteEnv } = await import("../../site-env.js");
+    const { spawnSync } = await import("child_process");
+    let spinner;
     while (true) {
         const exists = await fs
             .access(SiteEnv.valuesFile())
             .then(() => true)
             .catch(() => false);
         if (!exists) {
+            spinner = createSpinner("Cannot find SST environment variables. Waiting for SST to start...").start();
             await new Promise((resolve) => setTimeout(resolve, 1000));
             continue;
         }
-        spinner.succeed();
+        spinner?.succeed();
         const sites = await SiteEnv.values();
-        const current = path.relative(project.paths.root, process.cwd());
-        const env = sites[current] || {};
-        console.log(args.command);
+        const env = sites[process.cwd()] || {};
         const result = spawnSync(args.command, {
             env: {
                 ...process.env,

package/cli/commands/plugins/kysely.js

@@ -5,7 +5,9 @@ import * as fs from "fs/promises";
 import { DatabaseMetadata, EnumCollection, PostgresDialect, Serializer, Transformer, } from "kysely-codegen";
 import { Context } from "../../../context/context.js";
 import { useBus } from "../../../bus.js";
-import { useProject } from "../../../app.js";
+import { useProject } from "../../../project.js";
+import { Logger } from "../../../logger.js";
+import { useAWSCredentials, } from "../../../credentials.js";
 export const useKyselyTypeGenerator = Context.memo(async () => {
     let databases = [];
     const bus = useBus();
@@ -13,6 +15,8 @@ export const useKyselyTypeGenerator = Context.memo(async () => {
     async function generate(db) {
         if (!db.types)
             return;
+        Logger.debug("Generating types for", db.migratorID);
+        const credentials = await useAWSCredentials();
         const k = new Kysely({
             dialect: new DataApiDialect({
                 mode: db.engine.includes("postgres") ? "postgres" : "mysql",
@@ -21,7 +25,8 @@ export const useKyselyTypeGenerator = Context.memo(async () => {
                     resourceArn: db.clusterArn,
                     database: db.defaultDatabaseName,
                     client: new RDSDataService({
-                        region: project.region,
+                        region: project.config.region,
+                        credentials,
                     }),
                 },
             }),
@@ -67,13 +72,13 @@ export const useKyselyTypeGenerator = Context.memo(async () => {
         await fs.writeFile(db.types.path, data);
     }
     bus.subscribe("stacks.metadata", (evt) => {
-        databases = Object.values(evt.properties)
-            .flat()
+        const constructs = Object.values(evt.properties).flat();
+        databases = constructs
             .filter((c) => c.type === "RDS")
             .filter((c) => c.data.migrator)
             .filter((c) => c.data.types)
             .map((c) => ({
-            migratorID: evt.properties.metadata.find((fn) => fn.addr == c.data.migrator?.node).addr,
+            migratorID: constructs.find((fn) => fn.addr == c.data.migrator?.node).addr,
             clusterArn: c.data.clusterArn,
             types: c.data.types,
             engine: c.data.engine,
@@ -83,9 +88,12 @@ export const useKyselyTypeGenerator = Context.memo(async () => {
         databases.map((db) => generate(db));
     });
     bus.subscribe("function.success", async (evt) => {
+        if (!evt.properties.body?.results)
+            return;
         const db = databases.find((db) => db.migratorID === evt.properties.functionID);
         if (!db)
             return;
         generate(db);
     });
+    Logger.debug("Loaded kyseley type generator");
 });

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();
@@ -16,12 +17,16 @@ 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");
+            if (Array.isArray(route.commands) && route.commands.length > 0) {
+                await Promise.all(route.commands.map((cmd) => execAsync(cmd)));
+            }
+            Colors.line(Colors.success(`✔`), " Pothos: Extracted pothos schema");
         }
         catch (ex) {
-            console.error("Failed to extract schema from pothos");
-            console.error(ex);
+            Colors.line(Colors.danger(`✖`), " Pothos: Failed to extract schema:");
+            for (let line of ex.message.split("\n")) {
+                console.log(`  `, line);
+            }
         }
     }
     bus.subscribe("file.changed", async (evt) => {

package/cli/commands/remove.d.ts

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

package/cli/commands/remove.js

@@ -1,39 +1,47 @@
-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" })
-    .positional("filter", { type: "string" }), async (args) => {
+export const remove = (program) => program.command("remove [filter]", "Remove your app from AWS", (yargs) => yargs.option("from", { type: "string" }).positional("filter", {
+    type: "string",
+    describe: "Optionally filter stacks to remove",
+}), async (args) => {
     const React = await import("react");
-    const { CloudAssembly } = await import("aws-cdk-lib/cx-api");
-    const { blue, bold } = await import("colorette");
-    const { useProject } = await import("../../app.js");
-    const { Stacks } = await import("../../stacks/index.js");
+    const { dim, blue, bold } = await import("colorette");
+    const { useProject } = await import("../../project.js");
+    const { loadAssembly, clearAppMetadata, Stacks } = await import("../../stacks/index.js");
     const { render } = await import("ink");
     const { DeploymentUI } = await import("../ui/deploy.js");
+    const { printDeploymentResults } = await import("../ui/deploy.js");
+    const { Colors } = await import("../colors.js");
+    const { useSTSIdentity } = await import("../../credentials.js");
+    const project = useProject();
+    const identity = await useSTSIdentity();
+    Colors.line(`${Colors.primary.bold(`SST v${project.version}`)}`);
+    Colors.gap();
+    Colors.line(`${Colors.primary(`➜`)}  ${Colors.bold("App:")}     ${project.config.name}`);
+    Colors.line(`   ${Colors.bold("Stage:")}   ${project.config.stage}`);
+    Colors.line(`   ${Colors.bold("Region:")}  ${project.config.region}`);
+    Colors.line(`   ${Colors.bold("Account:")} ${identity.Account}`);
     const assembly = await (async function () {
         if (args.from) {
-            const result = new CloudAssembly(args.from);
+            const result = await loadAssembly(args.from);
             return result;
         }
-        const fn = await Stacks.build();
         return await Stacks.synth({
-            fn,
+            fn: project.stacks,
             mode: "remove",
         });
     })();
-    const project = useProject();
     const target = assembly.stacks.filter((s) => !args.filter ||
         s.stackName.toLowerCase().includes(args.filter.toLowerCase()));
     if (!target.length) {
         console.log(`No stacks found matching ${blue(args.filter)}`);
         process.exit(1);
-        return;
     }
-    console.log(`Removing ${bold(target.length + " stacks")} for stage ${blue(project.stage)}...`);
-    process.stdout.write("\x1b[?1049h");
-    const component = render(React.createElement(DeploymentUI, { stacks: target.map((s) => s.stackName) }));
+    const component = render(React.createElement(DeploymentUI, { assembly: assembly }));
     const results = await Stacks.removeMany(target);
+    component.clear();
     component.unmount();
-    process.stdout.write("\x1b[?1049l");
-    printDeploymentResults(results);
+    printDeploymentResults(assembly, results, true);
+    if (Object.values(results).some((stack) => Stacks.isFailed(stack.status)))
+        process.exit(1);
+    await clearAppMetadata();
     process.exit(0);
 });

package/cli/commands/secrets/get.d.ts

@@ -1,13 +1,17 @@
 /// <reference types="yargs" />
 import { Program } from "../../program.js";
-export declare const get: (program: Program) => import("yargs").Argv<import("yargs").Omit<{
+export declare const get: (program: Program) => import("yargs").Argv<{
     stage: string | undefined;
 } & {
     profile: string | undefined;
 } & {
     region: string | undefined;
+} & {
+    verbose: boolean | undefined;
+} & {
+    role: string | undefined;
 } & {
     name: string;
-}, "name"> & {
-    name: string;
+} & {
+    fallback: boolean | undefined;
 }>;

package/cli/commands/secrets/get.js

@@ -1,37 +1,24 @@
-import { red } from "colorette";
-export const get = (program) => program
-    .command("get <name>", "Get secret value", (yargs) => yargs.positional("name", {
+export const get = (program) => program.command("get <name>", "Get the value of a secret", (yargs) => yargs
+    .positional("name", {
     type: "string",
-    describe: "Name of secret",
+    describe: "Name of the secret",
     demandOption: true,
-}), async (args) => {
-    const { Config } = await import("../../../config.js");
-    const { bold } = await import("colorette");
-    try {
-        const result = await Config.getSecret({
-            key: args.name,
-        });
-        console.log(bold(result));
-    }
-    catch {
-        console.log(red(`${bold(args.name)} is not set`));
-    }
 })
-    .command("get-fallback <name>", "Get secret value", (yargs) => yargs.positional("name", {
-    type: "string",
-    describe: "Name of secret",
-    demandOption: true,
+    .option("fallback", {
+    type: "boolean",
+    describe: "Get the fallback value",
 }), async (args) => {
+    const { red } = await import("colorette");
     const { Config } = await import("../../../config.js");
-    const { bold } = await import("colorette");
+    const { Colors } = await import("../../colors.js");
     try {
         const result = await Config.getSecret({
             key: args.name,
-            fallback: true,
+            fallback: args.fallback === true,
         });
-        console.log(bold(result));
+        console.log(result);
     }
     catch {
-        console.log(red(`${bold(args.name)} is not set`));
+        Colors.line(Colors.danger(`✖ `), `"${args.name}" is not set`);
     }
 });

package/cli/commands/secrets/list.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="yargs" />
-import { Program } from "../../program.js";
+import type { Program } from "../../program.js";
 export declare const list: (program: Program) => import("yargs").Argv<{
     stage: string | undefined;
 } & {
@@ -7,5 +7,9 @@ export declare const list: (program: Program) => import("yargs").Argv<{
 } & {
     region: string | undefined;
 } & {
-    format: string;
+    verbose: boolean | undefined;
+} & {
+    role: string | undefined;
+} & {
+    format: string | undefined;
 }>;

package/cli/commands/secrets/list.js

@@ -1,8 +1,16 @@
-import { Config } from "../../../config.js";
-import { gray } from "colorette";
-export const list = (program) => program.command("list [format]", "Fetch and decrypt all secrets", yargs => yargs.positional("format", { type: "string", default: "table" }), async (args) => {
+export const list = (program) => program.command("list [format]", "Fetch all the secrets", (yargs) => yargs.positional("format", {
+    type: "string",
+    choices: ["table", "env"],
+}), async (args) => {
+    const { Config } = await import("../../../config.js");
+    const { gray } = await import("colorette");
+    const { Colors } = await import("../../colors.js");
     const secrets = await Config.secrets();
-    switch (args.format) {
+    if (Object.entries(secrets).length === 0) {
+        Colors.line("No secrets set");
+        return;
+    }
+    switch (args.format || "table") {
         case "env":
             for (const [key, value] of Object.entries(secrets)) {
                 console.log(`${key}=${value.value || value.fallback}`);
@@ -10,8 +18,8 @@ export const list = (program) => program.command("list [format]", "Fetch and dec
             break;
         case "table":
             const keys = Object.keys(secrets);
-            const keyLen = Math.max("Secrets".length, ...keys.map(key => key.length));
-            const valueLen = Math.max("Values".length, ...keys.map(key => secrets[key].value
+            const keyLen = Math.max("Secrets".length, ...keys.map((key) => key.length));
+            const valueLen = Math.max("Values".length, ...keys.map((key) => secrets[key].value
                 ? secrets[key].value.length
                 : `${secrets[key].fallback} (fallback)`.length));
             console.log("┌".padEnd(keyLen + 3, "─") +
@@ -23,7 +31,7 @@ export const list = (program) => program.command("list [format]", "Fetch and dec
                 "┼" +
                 "".padEnd(valueLen + 2, "─") +
                 "┤");
-            keys.sort().forEach(key => {
+            keys.sort().forEach((key) => {
                 const value = secrets[key].value
                     ? secrets[key].value
                     : `${secrets[key].fallback} ${gray("(fallback)")}`;

package/cli/commands/secrets/remove.d.ts

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

package/cli/commands/secrets/remove.js

@@ -1,21 +1,23 @@
-import { Config } from "../../../config.js";
-export const remove = (program) => program
-    .command("remove <name>", "Remove secret", (yargs) => yargs.positional("name", {
-    describe: "Name of secret to remove",
+export const remove = (program) => program.command("remove <name>", "Remove a secret", (yargs) => yargs
+    .positional("name", {
+    describe: "Name of the secret",
     type: "string",
     demandOption: true,
-}), async (args) => {
-    await Config.removeSecret({
-        key: args.name,
-    });
 })
-    .command("remove-fallback <name>", "Remove secret", (yargs) => yargs.positional("name", {
-    describe: "Name of secret to remove",
-    type: "string",
-    demandOption: true,
+    .option("fallback", {
+    type: "boolean",
+    describe: "Remove the fallback value",
 }), async (args) => {
-    await Config.removeSecret({
-        key: args.name,
-        fallback: true,
-    });
+    const { Config } = await import("../../../config.js");
+    const { Colors } = await import("../../colors.js");
+    try {
+        await Config.removeSecret({
+            key: args.name,
+            fallback: args.fallback === true,
+        });
+        Colors.line(Colors.success(`✔ `), `Removed "${args.name}"`);
+    }
+    catch {
+        Colors.line(Colors.danger(`✖ `), `"${args.name}" is not set`);
+    }
 });

package/cli/commands/secrets/secrets.js

@@ -3,12 +3,12 @@ import { list } from "./list.js";
 import { remove } from "./remove.js";
 import { set } from "./set.js";
 export function secrets(program) {
-    program.command("secrets", "Manage secrets", (yargs) => {
+    program.command("secrets", "Manage the secrets in your app", (yargs) => {
         yargs.demandCommand(1);
-        remove(yargs);
+        set(yargs);
         get(yargs);
         list(yargs);
-        set(yargs);
+        remove(yargs);
         return yargs;
     });
 }

package/cli/commands/secrets/set.d.ts

@@ -1,17 +1,19 @@
 /// <reference types="yargs" />
-import { Program } from "../../program.js";
-export declare const set: (program: Program) => import("yargs").Argv<import("yargs").Omit<import("yargs").Omit<{
+import type { Program } from "../../program.js";
+export declare const set: (program: Program) => import("yargs").Argv<{
     stage: string | undefined;
 } & {
     profile: string | undefined;
 } & {
     region: string | undefined;
 } & {
-    name: string;
+    verbose: boolean | undefined;
+} & {
+    role: string | undefined;
 } & {
-    value: string;
-}, "name"> & {
     name: string;
-}, "value"> & {
+} & {
     value: string;
+} & {
+    fallback: boolean | undefined;
 }>;

package/cli/commands/secrets/set.js

@@ -1,46 +1,29 @@
-import { Config } from "../../../config.js";
-import { blue } from "colorette";
-import { createSpinner } from "../../spinner.js";
-export const set = (program) => program
-    .command("set <name> <value>", "Set secret value", yargs => yargs
+export const set = (program) => program.command("set <name> <value>", "Set the value of a secret", (yargs) => yargs
     .positional("name", {
     type: "string",
-    describe: "Name of secret",
-    demandOption: true
+    describe: "Name of the secret",
+    demandOption: true,
 })
     .positional("value", {
     type: "string",
-    describe: "Value to set",
-    demandOption: true
-}), async (args) => {
-    const setting = createSpinner(`Setting secret ${blue(args.name)}`).start();
-    await Config.setSecret({
-        key: args.name,
-        value: args.value
-    });
-    setting.succeed();
-    const restarting = createSpinner(`Restarting all functions using ${blue(args.name)}...`).start();
-    const count = await Config.restart(args.name);
-    restarting.succeed(`Restarted ${blue(count)} functions`);
+    describe: "Value of the secret",
+    demandOption: true,
 })
-    .command("set-fallback <name> <value>", "Set a fallback value for secret", yargs => yargs
-    .positional("name", {
-    type: "string",
-    describe: "Name of secret",
-    demandOption: true
-})
-    .positional("value", {
-    type: "string",
-    describe: "Value to set",
-    demandOption: true
+    .option("fallback", {
+    type: "boolean",
+    describe: "Set the fallback value",
 }), async (args) => {
-    console.log("Setting", `${blue(args.name)}...`);
+    const { Config } = await import("../../../config.js");
+    const { blue } = await import("colorette");
+    const { createSpinner } = await import("../../spinner.js");
+    const setting = createSpinner(` Setting "${args.name}"`).start();
     await Config.setSecret({
         key: args.name,
         value: args.value,
-        fallback: true
+        fallback: args.fallback === true,
     });
-    console.log("Restarting all functions using", `${blue(args.name)}...`);
+    setting.succeed();
+    const restarting = createSpinner(` Restarting all functions using ${blue(args.name)}...`).start();
     const count = await Config.restart(args.name);
-    console.log("✅ Restarted", `${blue(count)}`, "functions");
+    restarting.succeed(` Restarted ${count} functions`);
 });

package/cli/commands/telemetry.d.ts

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

package/cli/commands/telemetry.js

@@ -0,0 +1,17 @@
+import { Colors } from "../colors.js";
+export const telemetry = (program) => program.command("telemetry <action>", "Load environment variables and start your frontend", (yargs) => yargs.positional("action", {
+    type: "string",
+    describe: "Whether to enable or disable",
+    choices: ["enable", "disable"],
+    demandOption: true,
+}), async (args) => {
+    const { enable, disable } = await import("../telemetry/telemetry.js");
+    if (args.action === "enable") {
+        enable();
+        Colors.line(Colors.success(`✔ `), `Telemetry enabled`);
+    }
+    if (args.action === "disable") {
+        disable();
+        Colors.line(Colors.success(`✔ `), `Telemetry disabled`);
+    }
+});

package/cli/commands/transform.d.ts

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