sst 1.16.0 → 2.0.0-rc.1

package/cli/commands/dev.js

@@ -0,0 +1,188 @@
+import path from "path";
+import fs from "fs/promises";
+import crypto from "crypto";
+import { printDeploymentResults } from "../ui/deploy.js";
+import { useFunctions } from "../../constructs/Function.js";
+import { dim, gray, yellow } from "colorette";
+import { useProject } from "../../app.js";
+import { SiteEnv } from "../../site-env.js";
+import { usePothosBuilder } from "./plugins/pothos.js";
+import { useKyselyTypeGenerator } from "./plugins/kysely.js";
+import { useRDSWarmer } from "./plugins/warmer.js";
+export const dev = (program) => program.command(["start", "dev"], "Work on your SST app locally", (yargs) => yargs.option("fullscreen", {
+    type: "boolean",
+    describe: "Disable full screen UI",
+    default: true,
+}), async (args) => {
+    const { useRuntimeWorkers } = await import("../../runtime/workers.js");
+    const { useIOTBridge } = await import("../../runtime/iot.js");
+    const { useRuntimeServer } = await import("../../runtime/server.js");
+    const { useBus } = await import("../../bus.js");
+    const { useWatcher } = await import("../../watcher.js");
+    const { Stacks } = await import("../../stacks/index.js");
+    const { Logger } = await import("../../logger.js");
+    const { createSpinner } = await import("../spinner.js");
+    const { bold, magenta, green, blue, red } = await import("colorette");
+    const { render } = await import("ink");
+    const React = await import("react");
+    const { Context } = await import("../../context/context.js");
+    const { DeploymentUI } = await import("../ui/deploy.js");
+    const { useLocalServer } = await import("../local/server.js");
+    if (args._[0] === "start") {
+        console.log(yellow(`Warning: ${bold(`sst start`)} has been renamed to ${bold(`sst dev`)}`));
+    }
+    const useFunctionLogger = Context.memo(async () => {
+        const bus = useBus();
+        bus.subscribe("function.invoked", async (evt) => {
+            console.log(bold(magenta(`Invoked `)), bold(useFunctions().fromID(evt.properties.functionID).handler));
+        });
+        bus.subscribe("function.build.success", async (evt) => {
+            console.log(bold(gray(`Built   `)), bold(useFunctions().fromID(evt.properties.functionID).handler));
+        });
+        bus.subscribe("function.build.failed", async (evt) => {
+            console.log(bold(red(`Build failed `)), bold(useFunctions().fromID(evt.properties.functionID).handler));
+            console.log(dim(evt.properties.errors.join("\n")));
+        });
+        bus.subscribe("worker.stdout", async (evt) => {
+            const { message } = evt.properties;
+            const lines = message.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                lines[i] = "         " + line;
+            }
+            console.log(bold(blue(`Log     `)), bold(useFunctions().fromID(evt.properties.functionID).handler));
+            console.log(dim(lines.join("\n")));
+        });
+        bus.subscribe("function.success", async (evt) => {
+            console.log(bold(green(`Success `)), bold(useFunctions().fromID(evt.properties.functionID).handler));
+        });
+        bus.subscribe("function.error", async (evt) => {
+            console.log(bold(red(`Error   `)), bold(useFunctions().fromID(evt.properties.functionID).handler), evt.properties.errorMessage);
+            for (const line of evt.properties.trace || []) {
+                console.log(`         ${dim(line)}`);
+            }
+        });
+    });
+    const useStackBuilder = Context.memo(async () => {
+        const watcher = useWatcher();
+        const bus = useBus();
+        const project = useProject();
+        let lastDeployed;
+        let pending;
+        let isDeploying = false;
+        async function build() {
+            const spinner = createSpinner("Building stacks").start();
+            try {
+                const fn = await Stacks.build();
+                const assembly = await Stacks.synth({
+                    fn,
+                    outDir: `.sst/cdk.out`,
+                    mode: "dev",
+                });
+                Logger.debug("Directory", assembly.directory);
+                const next = await checksum(assembly.directory);
+                Logger.debug("Checksum", "next", next, "old", lastDeployed);
+                if (next === lastDeployed) {
+                    spinner.succeed("Stacks built! No changes");
+                    return;
+                }
+                spinner.succeed(lastDeployed ? `Stacks built!` : `Stacks built!`);
+                pending = assembly;
+                if (lastDeployed)
+                    deploy();
+            }
+            catch (ex) {
+                spinner.fail();
+                console.error(ex);
+            }
+        }
+        async function deploy() {
+            if (!pending)
+                return;
+            if (isDeploying)
+                return;
+            isDeploying = true;
+            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 results = await Stacks.deployMany(assembly.stacks);
+            if (component)
+                component.unmount();
+            process.stdout.write("\x1b[?1049l");
+            lastDeployed = nextChecksum;
+            printDeploymentResults(results);
+            const keys = await SiteEnv.keys();
+            if (keys.length) {
+                const result = {};
+                for (const key of keys) {
+                    const stack = results[key.stack];
+                    const value = stack.outputs[key.output];
+                    let existing = result[key.path];
+                    if (!existing) {
+                        result[key.path] = existing;
+                        existing = result[key.path] = {};
+                    }
+                    existing[key.environment] = value;
+                }
+                await SiteEnv.writeValues(result);
+            }
+            isDeploying = false;
+            deploy();
+        }
+        async function checksum(cdkOutPath) {
+            const manifestPath = path.join(cdkOutPath, "manifest.json");
+            const cdkManifest = JSON.parse(await fs.readFile(manifestPath).then((x) => x.toString()));
+            const checksumData = await Promise.all(Object.keys(cdkManifest.artifacts)
+                .filter((key) => cdkManifest.artifacts[key].type === "aws:cloudformation:stack")
+                .map(async (key) => {
+                const { templateFile } = cdkManifest.artifacts[key].properties;
+                const templatePath = path.join(cdkOutPath, templateFile);
+                const templateContent = await fs.readFile(templatePath);
+                return templateContent;
+            })).then((x) => x.join("\n"));
+            const hash = crypto
+                .createHash("sha256")
+                .update(checksumData)
+                .digest("hex");
+            return hash;
+        }
+        let metafile;
+        bus.subscribe("stack.built", async (evt) => {
+            metafile = evt.properties.metafile;
+        });
+        watcher.subscribe("file.changed", async (evt) => {
+            if (!metafile)
+                return;
+            if (!metafile.inputs[evt.properties.relative])
+                return;
+            build();
+        });
+        await build();
+        await deploy();
+    });
+    createSpinner("").start().succeed("Ready for function invocations");
+    createSpinner("")
+        .start()
+        .succeed(`Console ready at https://console.sst.dev`);
+    await Promise.all([
+        useLocalServer({
+            key: "",
+            cert: "",
+            live: true,
+            port: 13557,
+        }),
+        useRuntimeWorkers(),
+        useIOTBridge(),
+        useRuntimeServer(),
+        usePothosBuilder(),
+        useKyselyTypeGenerator(),
+        useRDSWarmer(),
+        useFunctionLogger(),
+        useStackBuilder(),
+    ]);
+});

package/cli/commands/env.d.ts

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

package/cli/commands/env.js

@@ -0,0 +1,39 @@
+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", {
+    type: "string",
+    describe: "Command to run with environment variabels loaded",
+    demandOption: true,
+}), async (args) => {
+    const project = useProject();
+    const spinner = createSpinner("Waiting for SST to start").start();
+    while (true) {
+        const exists = await fs
+            .access(SiteEnv.valuesFile())
+            .then(() => true)
+            .catch(() => false);
+        if (!exists) {
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+            continue;
+        }
+        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 result = spawnSync(args.command, {
+            env: {
+                ...process.env,
+                ...env,
+            },
+            stdio: "inherit",
+            shell: process.env.SHELL || true,
+        });
+        process.exitCode = result.status || undefined;
+        break;
+    }
+});

package/cli/commands/plugins/kysely.d.ts

@@ -0,0 +1 @@
+export declare const useKyselyTypeGenerator: () => Promise<void>;

package/cli/commands/plugins/kysely.js

@@ -0,0 +1,91 @@
+import { Kysely } from "kysely";
+import { DataApiDialect } from "kysely-data-api";
+import RDSDataService from "aws-sdk/clients/rdsdataservice.js";
+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";
+export const useKyselyTypeGenerator = Context.memo(async () => {
+    let databases = [];
+    const bus = useBus();
+    const project = useProject();
+    async function generate(db) {
+        if (!db.types)
+            return;
+        const k = new Kysely({
+            dialect: new DataApiDialect({
+                mode: db.engine.includes("postgres") ? "postgres" : "mysql",
+                driver: {
+                    secretArn: db.secretArn,
+                    resourceArn: db.clusterArn,
+                    database: db.defaultDatabaseName,
+                    client: new RDSDataService({
+                        region: project.region,
+                    }),
+                },
+            }),
+        });
+        const tables = await k.introspection.getTables();
+        const metadata = db.engine.includes("postgres")
+            ? tables.map((table) => ({
+                ...table,
+                columns: table.columns.map((column) => {
+                    const isArray = column.dataType.startsWith("_");
+                    return {
+                        ...column,
+                        dataType: isArray ? column.dataType.slice(1) : column.dataType,
+                        enumValues: null,
+                        isArray,
+                    };
+                }),
+            }))
+            : tables.map((table) => ({
+                ...table,
+                columns: table.columns.map((column) => ({
+                    ...column,
+                    enumValues: null,
+                })),
+            }));
+        const transformer = new Transformer();
+        const nodes = transformer.transform({
+            dialect: new PostgresDialect(),
+            camelCase: db.types.camelCase === "true",
+            metadata: new DatabaseMetadata(metadata, new EnumCollection()),
+        });
+        const lastIndex = nodes.length - 1;
+        const last = nodes[lastIndex];
+        nodes[lastIndex] = {
+            ...last,
+            argument: {
+                ...last.argument,
+                name: "Database",
+            },
+        };
+        const serializer = new Serializer();
+        const data = serializer.serialize(nodes);
+        await fs.writeFile(db.types.path, data);
+    }
+    bus.subscribe("stacks.metadata", (evt) => {
+        databases = Object.values(evt.properties)
+            .flat()
+            .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,
+            clusterArn: c.data.clusterArn,
+            types: c.data.types,
+            engine: c.data.engine,
+            defaultDatabaseName: c.data.defaultDatabaseName,
+            secretArn: c.data.secretArn,
+        }));
+        databases.map((db) => generate(db));
+    });
+    bus.subscribe("function.success", async (evt) => {
+        const db = databases.find((db) => db.migratorID === evt.properties.functionID);
+        if (!db)
+            return;
+        generate(db);
+    });
+});

package/cli/commands/plugins/pothos.d.ts

@@ -0,0 +1 @@
+export declare const usePothosBuilder: () => void;

package/cli/commands/plugins/pothos.js

@@ -0,0 +1,52 @@
+import { useBus } from "../../../bus.js";
+import { Context } from "../../../context/context.js";
+import { Pothos } from "../../../pothos.js";
+import fs from "fs/promises";
+import { exec } from "child_process";
+import { promisify } from "util";
+const execAsync = promisify(exec);
+import path from "path";
+export const usePothosBuilder = Context.memo(() => {
+    let routes = [];
+    const bus = useBus();
+    async function build(route) {
+        try {
+            const schema = await Pothos.generate({
+                schema: route.schema,
+            });
+            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");
+        }
+        catch (ex) {
+            console.error("Failed to extract schema from pothos");
+            console.error(ex);
+        }
+    }
+    bus.subscribe("file.changed", async (evt) => {
+        if (evt.properties.file.endsWith("out.mjs"))
+            return;
+        for (const route of routes) {
+            const dir = path.dirname(route.schema);
+            const relative = path.relative(dir, evt.properties.file);
+            if (relative && !relative.startsWith("..") && !path.isAbsolute(relative))
+                build(route);
+        }
+    });
+    let first = false;
+    bus.subscribe("stacks.metadata", async (evt) => {
+        routes = Object.values(evt.properties)
+            .flat()
+            .filter((c) => c.type == "Api")
+            .flatMap((c) => c.data.routes)
+            .filter((r) => ["pothos", "graphql"].includes(r.type))
+            .filter((r) => r.schema);
+        if (first)
+            return;
+        for (const route of routes) {
+            build(route);
+            first = true;
+        }
+    });
+});

package/cli/commands/plugins/warmer.d.ts

@@ -0,0 +1 @@
+export declare const useRDSWarmer: () => Promise<void>;

package/cli/commands/plugins/warmer.js

@@ -0,0 +1,33 @@
+import { useBus } from "../../../bus.js";
+import { Context } from "../../../context/context.js";
+import { RDSDataClient, ExecuteStatementCommand, } from "@aws-sdk/client-rds-data";
+import { useAWSClient } from "../../../credentials.js";
+export const useRDSWarmer = Context.memo(async () => {
+    let interval;
+    const bus = useBus();
+    const client = useAWSClient(RDSDataClient);
+    bus.subscribe("stacks.metadata", (evt) => {
+        if (interval)
+            clearInterval(interval);
+        interval = setInterval(() => {
+            Object.values(evt.properties)
+                .flat()
+                .filter((c) => c.type === "RDS")
+                .map((c) => {
+                try {
+                    client.send(new ExecuteStatementCommand({
+                        sql: "SELECT 1",
+                        secretArn: c.data.secretArn,
+                        resourceArn: c.data.clusterArn,
+                        database: c.data.defaultDatabaseName,
+                    }));
+                }
+                catch (e) {
+                    // Ignore error
+                    // If the cluster is not warm, this will throw:
+                    //   BadRequestException: Communication link failure
+                }
+            });
+        }, 1000 * 60);
+    });
+});

package/cli/commands/remove.d.ts

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

package/cli/commands/remove.js

@@ -0,0 +1,39 @@
+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) => {
+    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 { render } = await import("ink");
+    const { DeploymentUI } = await import("../ui/deploy.js");
+    const assembly = await (async function () {
+        if (args.from) {
+            const result = new CloudAssembly(args.from);
+            return result;
+        }
+        const fn = await Stacks.build();
+        return await Stacks.synth({
+            fn,
+            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 results = await Stacks.removeMany(target);
+    component.unmount();
+    process.stdout.write("\x1b[?1049l");
+    printDeploymentResults(results);
+    process.exit(0);
+});

package/{dist/cli → cli}/commands/secrets/get.d.ts

@@ -4,6 +4,8 @@ export declare const get: (program: Program) => import("yargs").Argv<import("yar
     stage: string | undefined;
 } & {
     profile: string | undefined;
+} & {
+    region: string | undefined;
 } & {
     name: string;
 }, "name"> & {

package/{dist/cli → cli}/commands/secrets/list.d.ts

@@ -4,6 +4,8 @@ export declare const list: (program: Program) => import("yargs").Argv<{
     stage: string | undefined;
 } & {
     profile: string | undefined;
+} & {
+    region: string | undefined;
 } & {
     format: string;
 }>;

package/{dist/cli → cli}/commands/secrets/list.js

@@ -1,6 +1,6 @@
 import { Config } from "../../../config.js";
-export const list = (program) => program.command("list [format]", "Fetch and decrypt all secrets", (yargs) => yargs.positional("format", { type: "string", default: "table" }), async (args) => {
-    const { gray } = await import("colorette");
+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) => {
     const secrets = await Config.secrets();
     switch (args.format) {
         case "env":
@@ -10,8 +10,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 +23,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/{dist/cli → cli}/commands/secrets/remove.d.ts

@@ -4,6 +4,8 @@ export declare const remove: (program: Program) => import("yargs").Argv<import("
     stage: string | undefined;
 } & {
     profile: string | undefined;
+} & {
+    region: string | undefined;
 } & {
     name: string;
 }, "name"> & {

package/{dist/cli → cli}/commands/secrets/set.d.ts

@@ -4,6 +4,8 @@ export declare const set: (program: Program) => import("yargs").Argv<import("yar
     stage: string | undefined;
 } & {
     profile: string | undefined;
+} & {
+    region: string | undefined;
 } & {
     name: string;
 } & {

package/{dist/cli → cli}/commands/secrets/set.js

@@ -1,42 +1,44 @@
 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
+    .command("set <name> <value>", "Set secret value", yargs => yargs
     .positional("name", {
     type: "string",
     describe: "Name of secret",
-    demandOption: true,
+    demandOption: true
 })
     .positional("value", {
     type: "string",
     describe: "Value to set",
-    demandOption: true,
+    demandOption: true
 }), async (args) => {
-    console.log("Setting", `${blue(args.name)}...`);
+    const setting = createSpinner(`Setting secret ${blue(args.name)}`).start();
     await Config.setSecret({
         key: args.name,
-        value: args.value,
+        value: args.value
     });
-    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 ${blue(count)} functions`);
 })
-    .command("set-fallback <name> <value>", "Set a fallback value for secret", (yargs) => yargs
+    .command("set-fallback <name> <value>", "Set a fallback value for secret", yargs => yargs
     .positional("name", {
     type: "string",
     describe: "Name of secret",
-    demandOption: true,
+    demandOption: true
 })
     .positional("value", {
     type: "string",
     describe: "Value to set",
-    demandOption: true,
+    demandOption: true
 }), async (args) => {
     console.log("Setting", `${blue(args.name)}...`);
     await Config.setSecret({
         key: args.name,
         value: args.value,
-        fallback: true,
+        fallback: true
     });
     console.log("Restarting all functions using", `${blue(args.name)}...`);
     const count = await Config.restart(args.name);

package/{dist/cli → cli}/commands/update.d.ts

@@ -4,6 +4,8 @@ export declare const update: (program: Program) => import("yargs").Argv<{
     stage: string | undefined;
 } & {
     profile: string | undefined;
+} & {
+    region: string | undefined;
 } & {
     ver: string | undefined;
 }>;