sst 3.0.0 → 3.0.1-1

package/cli/commands/update.js

@@ -1,116 +0,0 @@
-const FIELDS = ["dependencies", "devDependencies"];
-const SST_PKGS = ["sst", "astro-sst", "svelte-kit-sst", "solid-start-sst"];
-export const update = (program) => program.command("update [version]", "Update your SST and CDK packages", (yargs) => yargs.positional("version", {
-    type: "string",
-    describe: "Optionally specify a version to update to",
-}), async (args) => {
-    const fs = await import("fs/promises");
-    const path = await import("path");
-    const { fetch } = await import("undici");
-    const { exit, exitWithError } = await import("../program.js");
-    const { useProject } = await import("../../project.js");
-    const { VisibleError } = await import("../../error.js");
-    const { Colors } = await import("../colors.js");
-    try {
-        const project = useProject();
-        const files = await findAllPackageJson(project.paths.root);
-        const metadata = await fetch(`https://registry.npmjs.org/sst/${args.version || "latest"}`).then((resp) => resp.json());
-        const allChanges = new Map();
-        const allOldPackages = new Map();
-        // Update all package.json files
-        await Promise.all(files.map(updatePackageJson));
-        // Print status
-        if (allOldPackages.size > 0) {
-            for (const [file, pkgs] of allOldPackages.entries()) {
-                Colors.line(Colors.danger(`✖ `), Colors.bold.dim(path.relative(project.paths.root, file)));
-                for (const [pkg, version] of pkgs) {
-                    Colors.line(Colors.dim(`   ${pkg}@${version}`));
-                }
-            }
-            Colors.gap();
-            throw new VisibleError("We've detected AWS CDK v1 dependencies in your package.json. SST requires CDK v2. Please update to CDK v2 dependencies, and then execute `sst update`. Refer to the official AWS CDK migration documentation — https://docs.aws.amazon.com/cdk/v2/guide/migrating-v2.html#migrating-v2-v1-upgrade");
-        }
-        // Print status
-        if (allChanges.size === 0) {
-            Colors.line(Colors.success(`✔ `), `Already using v${metadata.version}`);
-            return;
-        }
-        for (const [file, pkgs] of allChanges.entries()) {
-            Colors.line(Colors.success(`✔ `), Colors.bold.dim(path.relative(project.paths.root, file)));
-            for (const [pkg, version] of pkgs) {
-                Colors.line(Colors.dim(`   ${pkg}@${version}`));
-            }
-        }
-        Colors.gap();
-        Colors.line(`${Colors.primary(`➜`)}  ${Colors.warning("Make sure to run: npm install (or pnpm install, or yarn)")}`);
-        /////////////
-        // Helpers
-        /////////////
-        async function findAllPackageJson(dir) {
-            const children = await fs.readdir(dir);
-            const tasks = children.map(async (item) => {
-                if (item === "node_modules")
-                    return [];
-                // Ignore hidden paths
-                if (/(^|\/)\.[^\/\.]/g.test(item))
-                    return [];
-                const full = path.join(dir, item);
-                if (item === "package.json")
-                    return [full];
-                const stat = await fs.stat(full);
-                if (stat.isDirectory())
-                    return findAllPackageJson(full);
-                return [];
-            });
-            return (await Promise.all(tasks)).flat();
-        }
-        async function updatePackageJson(file) {
-            const changes = new Set();
-            const oldPackages = new Set();
-            const data = await fs.readFile(file).then((x) => x.toString());
-            const json = JSON.parse(data);
-            // Update versions
-            for (const field of FIELDS) {
-                const deps = json[field];
-                for (const [pkg, existing] of Object.entries(deps || {})) {
-                    const desired = (() => {
-                        if (SST_PKGS.includes(pkg)) {
-                            return metadata.version;
-                        }
-                        else if (pkg === "constructs") {
-                            return metadata.dependencies.constructs;
-                        }
-                        else if (pkg === "aws-cdk-lib") {
-                            return metadata.dependencies["aws-cdk-lib"];
-                        }
-                        else if (pkg.startsWith("@aws-cdk/aws-")) {
-                            if (!pkg.endsWith("-alpha")) {
-                                oldPackages.add([pkg, existing]);
-                                return;
-                            }
-                            return metadata.dependencies["@aws-cdk/aws-apigatewayv2-alpha"];
-                        }
-                    })();
-                    if (!desired || existing === desired)
-                        continue;
-                    changes.add([pkg, desired]);
-                    deps[pkg] = desired;
-                }
-            }
-            // Write to package.json
-            if (changes.size > 0) {
-                // note: preserve ending new line characters in package.json
-                const tailingNewline = data.match(/\r?\n$/)?.[0];
-                await fs.writeFile(file, `${JSON.stringify(json, null, 2)}${tailingNewline ?? ""}`);
-                allChanges.set(file, changes);
-            }
-            if (oldPackages.size > 0) {
-                allOldPackages.set(file, oldPackages);
-            }
-        }
-        await exit();
-    }
-    catch (e) {
-        await exitWithError(e);
-    }
-});

package/cli/commands/version.d.ts

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

package/cli/commands/version.js

@@ -1,15 +0,0 @@
-export const version = (program) => program.command("version", "Print SST and CDK version", (yargs) => yargs, async () => {
-    const { exit, exitWithError } = await import("../program.js");
-    const { Colors } = await import("../colors.js");
-    const { useProject } = await import("../../project.js");
-    try {
-        const project = useProject();
-        Colors.line(Colors.bold(`SST:`), `v${project.version}`);
-        Colors.line(Colors.bold(`CDK:`), `v${project.cdkVersion}`);
-        Colors.line(Colors.bold(`Constructs:`), `v${project.constructsVersion}`);
-        await exit();
-    }
-    catch (e) {
-        await exitWithError(e);
-    }
-});

package/cli/local/router.d.ts

@@ -1,44 +0,0 @@
-import * as trpc from "@trpc/server";
-import { DendriformPatch } from "dendriform-immer-patch-optimiser";
-import { useProject } from "../../project.js";
-export type State = {
-    app: string;
-    stage: string;
-    functions: Record<string, FunctionState>;
-    bootstrap: ReturnType<typeof useProject>["config"]["bootstrap"];
-    live: boolean;
-    stacks: {
-        status: any;
-    };
-};
-export type FunctionState = {
-    state: "idle" | "building" | "checking";
-    invocations: Invocation[];
-    issues: Record<string, any[]>;
-    warm: boolean;
-};
-export type Invocation = {
-    id: string;
-    request: any;
-    response?: any;
-    times: {
-        start: number;
-        end?: number;
-    };
-    logs: {
-        message: string;
-        timestamp: number;
-    }[];
-};
-export type Context = {
-    state: State;
-};
-export declare const router: import("@trpc/server/dist/declarations/src/router.js").Router<Context, Context, Record<"getCredentials", import("@trpc/server/dist/declarations/src/internals/procedure.js").Procedure<Context, Context, undefined, undefined, {
-    region: string | undefined;
-    credentials: {
-        accessKeyId: string;
-        secretAccessKey: string;
-        sessionToken: string | undefined;
-    };
-}>> & Record<"getState", import("@trpc/server/dist/declarations/src/internals/procedure.js").Procedure<Context, Context, undefined, undefined, State>>, Record<"deploy", import("@trpc/server/dist/declarations/src/internals/procedure.js").Procedure<Context, Context, undefined, undefined, void>>, Record<"onStateChange", import("@trpc/server/dist/declarations/src/internals/procedure.js").Procedure<Context, Context, undefined, undefined, trpc.Subscription<DendriformPatch[]>>>, trpc.DefaultErrorShape>;
-export type Router = typeof router;

package/cli/local/router.js

@@ -1,43 +0,0 @@
-import * as trpc from "@trpc/server";
-import { useProject } from "../../project.js";
-import { useBus } from "../../bus.js";
-import { useAWSCredentials } from "../../credentials.js";
-export const router = trpc
-    .router()
-    .query("getCredentials", {
-    async resolve({ ctx }) {
-        const project = useProject();
-        const credentials = await useAWSCredentials();
-        return {
-            region: project.config.region,
-            credentials: {
-                accessKeyId: credentials.accessKeyId,
-                secretAccessKey: credentials.secretAccessKey,
-                sessionToken: credentials.sessionToken,
-            },
-        };
-    },
-})
-    .query("getState", {
-    async resolve({ ctx }) {
-        return ctx.state;
-    },
-})
-    .mutation("deploy", {
-    async resolve() {
-        return;
-    },
-})
-    .subscription("onStateChange", {
-    async resolve({ ctx }) {
-        const bus = useBus();
-        return new trpc.Subscription((emit) => {
-            const sub = bus.subscribe("local.patches", (evt) => {
-                emit.data(evt.properties);
-            });
-            return () => {
-                bus.unsubscribe(sub);
-            };
-        });
-    },
-});

package/cli/local/server.d.ts

@@ -1,22 +0,0 @@
-import { FunctionState, State } from "./router.js";
-import { WritableDraft } from "immer/dist/internal.js";
-import { DendriformPatch } from "dendriform-immer-patch-optimiser";
-type Opts = {
-    key: any;
-    cert: any;
-    live: boolean;
-};
-declare module "../../bus.js" {
-    interface Events {
-        "local.patches": DendriformPatch[];
-    }
-}
-export declare const useLocalServerConfig: () => Promise<{
-    port: number;
-    url: string;
-}>;
-export declare function useLocalServer(opts: Opts): Promise<{
-    updateState: (cb: (draft: WritableDraft<State>) => void) => void;
-    updateFunction: (id: string, cb: (draft: WritableDraft<FunctionState>) => void) => void;
-}>;
-export {};

package/cli/local/server.js

@@ -1,319 +0,0 @@
-import { produceWithPatches, enablePatches } from "immer";
-import express from "express";
-import fs from "fs/promises";
-enablePatches();
-import { WebSocketServer } from "ws";
-import https from "https";
-import http from "http";
-import { applyWSSHandler } from "@trpc/server/adapters/ws/dist/trpc-server-adapters-ws.cjs.js";
-import { router } from "./router.js";
-import { optimise } from "dendriform-immer-patch-optimiser";
-import { sync } from "cross-spawn";
-import { useProject } from "../../project.js";
-import { useBus } from "../../bus.js";
-import getPort from "get-port";
-import { lazy } from "../../util/lazy.js";
-export const useLocalServerConfig = lazy(async () => {
-    const port = await getPort({
-        port: 13557,
-    });
-    return {
-        port,
-        url: `https://console.sst.dev${port !== 13557 ? `?_port=${port}` : ""}`,
-    };
-});
-export async function useLocalServer(opts) {
-    const cfg = await useLocalServerConfig();
-    const project = useProject();
-    let state = {
-        app: project.config.name,
-        stage: project.config.stage,
-        bootstrap: project.config.bootstrap,
-        live: opts.live,
-        stacks: {
-            status: "idle",
-        },
-        functions: {},
-    };
-    const rest = express();
-    rest.all(`/ping`, (req, res) => {
-        res.header("Access-Control-Allow-Origin", "*");
-        res.header("Access-Control-Allow-Methods", "GET, PUT, PATCH, POST, DELETE");
-        res.header("Access-Control-Allow-Headers", req.header("access-control-request-headers"));
-        res.sendStatus(200);
-    });
-    rest.all(`/proxy*`, express.raw({
-        type: "*/*",
-        limit: "1024mb",
-    }), (req, res) => {
-        res.header("Access-Control-Allow-Origin", "*");
-        res.header("Access-Control-Allow-Methods", "GET, PUT, PATCH, POST, DELETE");
-        res.header("Access-Control-Allow-Headers", req.header("access-control-request-headers"));
-        if (req.method === "OPTIONS")
-            return res.send();
-        const u = new URL(req.url.substring(7));
-        const forward = https.request(u, {
-            headers: {
-                ...req.headers,
-                host: u.hostname,
-            },
-            method: req.method,
-        }, (proxied) => {
-            res.status(proxied.statusCode);
-            for (const [key, value] of Object.entries(proxied.headers)) {
-                res.header(key, value);
-            }
-            proxied.pipe(res);
-        });
-        if (req.method !== "GET" &&
-            req.method !== "DELETE" &&
-            req.method !== "HEAD" &&
-            req.body)
-            forward.write(req.body);
-        forward.end();
-        forward.on("error", (e) => {
-            console.log(e.message);
-        });
-    });
-    const server = await (async () => {
-        const result = sync("mkcert", ["--help"]);
-        const KEY_PATH = ".sst/localhost-key.pem";
-        const CERT_PATH = ".sst/localhost.pem";
-        if (result.status === 0) {
-            try {
-                await Promise.all([fs.access(KEY_PATH), fs.access(CERT_PATH)]);
-            }
-            catch (e) {
-                sync("mkcert", ["localhost"], {
-                    cwd: ".sst",
-                });
-            }
-            const [key, cert] = await Promise.all([
-                fs.readFile(KEY_PATH),
-                fs.readFile(CERT_PATH),
-            ]);
-            return https.createServer({
-                key: key,
-                cert: cert,
-            }, rest);
-        }
-        return http.createServer({}, rest);
-    })();
-    // Wire up websocket
-    const wss = new WebSocketServer({ noServer: true });
-    const wss2 = new WebSocketServer({ noServer: true });
-    const sockets = new Set();
-    let invocations = [];
-    function publish(invocation) {
-        invocations.push(invocation);
-        const json = JSON.stringify({
-            type: "invocation",
-            properties: [invocation],
-        });
-        [...sockets.values()].map((s) => s.send(json));
-    }
-    wss2.on("connection", (socket, req) => {
-        sockets.add(socket);
-        socket.send(JSON.stringify({
-            type: "cli.dev",
-            properties: {
-                app: project.config.name,
-                stage: project.config.stage,
-            },
-        }));
-        for (const invocation of invocations) {
-            socket.send(JSON.stringify({
-                type: "invocation",
-                properties: [invocation],
-            }));
-        }
-        socket.on("close", () => {
-            sockets.delete(socket);
-        });
-        socket.on("message", (data) => {
-            const parsed = JSON.parse(data.toString());
-            if (parsed.type === "log.cleared") {
-                if (parsed.properties.source === "all") {
-                    invocations = [];
-                    return;
-                }
-                invocations = invocations.filter((item) => item.source === parsed.properties.source);
-            }
-        });
-    });
-    wss.on("connection", (socket, req) => {
-        if (req.headers.origin?.endsWith("localhost:3000"))
-            return;
-        if (req.headers.origin?.endsWith("localhost:3001"))
-            return;
-        if (req.headers.origin?.endsWith("console.serverless-stack.com"))
-            return;
-        if (req.headers.origin?.endsWith("console.sst.dev"))
-            return;
-        if (req.headers.origin?.endsWith("--sst-console.netlify.app"))
-            return;
-        console.log("Rejecting unauthorized connection from " + req.headers.origin);
-        socket.terminate();
-    });
-    server.on("upgrade", (req, socket, head) => {
-        if (req.url === "/socket") {
-            wss2.handleUpgrade(req, socket, head, (socket) => {
-                wss2.emit("connection", socket, req);
-            });
-            return;
-        }
-        if (req.url === "/") {
-            wss.handleUpgrade(req, socket, head, (socket) => {
-                wss.emit("connection", socket, req);
-            });
-            return;
-        }
-        socket.destroy();
-    });
-    server.listen(cfg.port);
-    const handler = applyWSSHandler({
-        wss,
-        router,
-        createContext() {
-            return {
-                state,
-            };
-        },
-    });
-    const bus = useBus();
-    const pending = [];
-    function updateState(cb) {
-        const [next, patches] = produceWithPatches(state, cb);
-        if (!patches.length)
-            return;
-        const scheduled = pending.length;
-        pending.push(...optimise(state, patches));
-        if (!scheduled)
-            setTimeout(() => {
-                bus.publish("local.patches", pending);
-                pending.splice(0, pending.length);
-            }, 0);
-        state = next;
-    }
-    function updateFunction(id, cb) {
-        return updateState((draft) => {
-            let func = draft.functions[id];
-            if (!func) {
-                func = {
-                    warm: true,
-                    state: "idle",
-                    issues: {},
-                    invocations: [],
-                };
-                draft.functions[id] = func;
-            }
-            cb(func);
-        });
-    }
-    bus.subscribe("function.invoked", async (evt) => {
-        publish({
-            start: Date.now(),
-            cold: false,
-            input: evt.properties.event,
-            id: evt.properties.requestID,
-            errors: [],
-            logs: [],
-            source: evt.properties.functionID,
-        });
-        updateFunction(evt.properties.functionID, (draft) => {
-            if (draft.invocations.length >= 25)
-                draft.invocations.pop();
-            draft.invocations.unshift({
-                id: evt.properties.context.awsRequestId,
-                request: evt.properties.event,
-                times: {
-                    start: Date.now(),
-                },
-                logs: [],
-            });
-        });
-    });
-    bus.subscribe("worker.stdout", (evt) => {
-        const invocation = invocations.findLast((i) => i.source === evt.properties.functionID);
-        if (invocation) {
-            invocation.logs.push({
-                id: Math.random().toString(),
-                message: evt.properties.message,
-                timestamp: Date.now(),
-            });
-            publish(invocation);
-        }
-        updateFunction(evt.properties.functionID, (draft) => {
-            const entry = draft.invocations.find((i) => i.id === evt.properties.requestID);
-            if (!entry)
-                return;
-            entry.logs.push({
-                timestamp: Date.now(),
-                message: evt.properties.message,
-            });
-        });
-    });
-    bus.subscribe("function.success", (evt) => {
-        const invocation = invocations.findLast((i) => i.source === evt.properties.functionID);
-        if (invocation) {
-            invocation.end = Date.now();
-            invocation.report = {
-                duration: invocation.end - invocation.start,
-                size: 0,
-                xray: "",
-                memory: 0,
-            };
-            invocation.output = evt.properties.body;
-            publish(invocation);
-        }
-        updateFunction(evt.properties.functionID, (draft) => {
-            const invocation = draft.invocations.find((x) => x.id === evt.properties.requestID);
-            if (!invocation)
-                return;
-            invocation.response = {
-                type: "success",
-                data: evt.properties.body,
-            };
-            invocation.times.end = Date.now();
-        });
-    });
-    bus.subscribe("function.error", (evt) => {
-        const invocation = invocations.findLast((i) => i.source === evt.properties.functionID);
-        if (invocation) {
-            invocation.errors.push({
-                id: invocation.id,
-                error: evt.properties.errorType,
-                message: evt.properties.errorMessage,
-                stack: evt.properties.trace.map((t) => ({
-                    raw: t,
-                })),
-            });
-            invocation.end = Date.now();
-            invocation.report = {
-                duration: invocation.end - invocation.start,
-                size: 0,
-                xray: "",
-                memory: 0,
-            };
-            publish(invocation);
-        }
-        updateFunction(evt.properties.functionID, (draft) => {
-            const invocation = draft.invocations.find((x) => x.id === evt.properties.requestID);
-            if (!invocation)
-                return;
-            invocation.response = {
-                type: "failure",
-                error: {
-                    errorMessage: evt.properties.errorMessage,
-                    stackTrace: evt.properties.trace || [],
-                },
-            };
-            invocation.times.end = Date.now();
-        });
-    });
-    const result = {
-        updateState,
-        updateFunction,
-    };
-    return result;
-}

package/cli/program.d.ts

@@ -1,19 +0,0 @@
-/// <reference types="yargs" />
-export declare const program: import("yargs").Argv<{
-    stage: string | undefined;
-} & {
-    profile: string | undefined;
-} & {
-    region: string | undefined;
-} & {
-    verbose: boolean | undefined;
-} & {
-    role: string | undefined;
-} & {
-    future: boolean | undefined;
-}>;
-export type Program = typeof program;
-export declare function exitWithError(error: Error): Promise<void>;
-export declare function exit(code?: number): Promise<void>;
-export declare function trackDevError(error: Error): Promise<void>;
-export declare function trackDevRunning(): Promise<void>;

package/cli/program.js

@@ -1,87 +0,0 @@
-import yargs from "yargs";
-import { hideBin } from "yargs/helpers";
-export const program = yargs(hideBin(process.argv))
-    .scriptName("sst")
-    .option("stage", {
-    type: "string",
-    describe: "The stage to use, defaults to personal stage",
-})
-    .option("profile", {
-    type: "string",
-    describe: "The AWS profile to use",
-})
-    .option("region", {
-    type: "string",
-    describe: "The AWS region to use",
-})
-    .option("verbose", {
-    type: "boolean",
-    describe: "Print verbose logs",
-})
-    .option("role", {
-    type: "string",
-    describe: "ARN of the IAM role to use when invoking AWS",
-})
-    .option("future", {
-    type: "boolean",
-    describe: "DO NOT USE. For enabling untested, experimental features",
-})
-    .group(["stage", "profile", "region", "role", "verbose", "help"], "Global:")
-    .middleware(async (argv) => {
-    if (argv.verbose) {
-        process.env.SST_VERBOSE = "1";
-    }
-    if (argv._.length > 0) {
-        const { initProject } = await import("../project.js");
-        await initProject(argv);
-        const { trackCli } = await import("./telemetry/telemetry.js");
-        trackCli(argv._[0]);
-    }
-})
-    .version(false)
-    .epilogue(`Join the SST community on Discord https://sst.dev/discord`)
-    .recommendCommands()
-    .demandCommand()
-    .strict()
-    .fail(async (_, error, yargs) => {
-    if (!error) {
-        yargs.showHelp();
-        process.exit(1);
-    }
-    throw error;
-});
-const startAt = Date.now();
-export async function exitWithError(error) {
-    const { trackCliFailed } = await import("./telemetry/telemetry.js");
-    await trackCliFailed({
-        rawCommand: process.argv.slice(2).join(" "),
-        duration: Date.now() - startAt,
-        errorName: error.name,
-        errorMessage: error.message,
-    });
-    throw error;
-}
-export async function exit(code) {
-    const { trackCliSucceeded } = await import("./telemetry/telemetry.js");
-    await trackCliSucceeded({
-        rawCommand: process.argv.slice(2).join(" "),
-        duration: Date.now() - startAt,
-    });
-    process.exit(code);
-}
-export async function trackDevError(error) {
-    const { trackCliDevError } = await import("./telemetry/telemetry.js");
-    await trackCliDevError({
-        rawCommand: process.argv.slice(2).join(" "),
-        duration: Date.now() - startAt,
-        errorName: error.name,
-        errorMessage: error.message,
-    });
-}
-export async function trackDevRunning() {
-    const { trackCliDevRunning } = await import("./telemetry/telemetry.js");
-    await trackCliDevRunning({
-        rawCommand: process.argv.slice(2).join(" "),
-        duration: Date.now() - startAt,
-    });
-}

package/cli/spinner.d.ts

@@ -1,3 +0,0 @@
-import { Options, Ora } from "ora";
-export declare const useSpinners: () => Ora[];
-export declare function createSpinner(options: Options | string): Ora;