sst 2.4.0 → 2.4.2

package/cli/commands/bind.js

@@ -1,11 +1,10 @@
 import path from "path";
 import { VisibleError } from "../../error.js";
-const SITE_CONFIG = {
+const SSR_SITE_CONFIG = {
     NextjsSite: "next.config",
     AstroSite: "astro.config",
     RemixSite: "remix.config",
     SolidStartSite: "vite.config",
-    StaticSite: "vite.config",
     SlsNextjsSite: "next.config",
 };
 export const bind = (program) => program
@@ -18,6 +17,7 @@ export const bind = (program) => program
     const { useBus } = await import("../../bus.js");
     const { useIOT } = await import("../../iot.js");
     const { Colors } = await import("../colors.js");
+    const { Logger } = await import("../../logger.js");
     if (args._[0] === "env") {
         Colors.line(Colors.warning(`Warning: ${Colors.bold(`sst env`)} has been renamed to ${Colors.bold(`sst bind`)}`));
     }
@@ -25,17 +25,18 @@ export const bind = (program) => program
     const bus = useBus();
     const project = useProject();
     const command = args.command?.join(" ");
-    const isFrontend = await isRunningInFrontend();
+    const isSsrSite = await isRunningInSsrSite();
     let p;
     let timer;
-    let metadataCache;
+    let siteConfigCache;
     // Handle missing command
     if (!command) {
-        throw new VisibleError(`Command is required, e.g. sst bind ${isFrontend ? "next dev" : "env"}`);
+        throw new VisibleError(`Command is required, e.g. sst bind ${isSsrSite ? "next dev" : "env"}`);
     }
     // Bind script
     const initialMetadata = await getSiteMetadata();
-    if (!initialMetadata) {
+    if (!initialMetadata && !isSsrSite) {
+        Logger.debug("Running in script mode.");
         return await bindScript();
     }
     // Bind site
@@ -44,33 +45,44 @@ export const bind = (program) => program
     bus.subscribe("stacks.metadata.deleted", () => bindSite("metadata_updated"));
     bus.subscribe("config.secret.updated", (payload) => {
         const secretName = payload.properties.name;
-        if (metadataCache?.secrets === undefined)
+        if (siteConfigCache?.secrets === undefined)
             return;
-        if (!metadataCache.secrets.includes(secretName))
+        if (!siteConfigCache.secrets.includes(secretName))
             return;
         Colors.line(`\n`, `SST secrets have been updated. Restarting \`${command}\`...`);
         bindSite("secrets_updated");
     });
-    async function isRunningInFrontend() {
+    async function isRunningInSsrSite() {
         const { existsAsync } = await import("../../util/fs.js");
-        const results = await Promise.all(Object.values(SITE_CONFIG)
-            .map((config) => [".js", ".cjs", ".mjs", ".ts"].map((ext) => existsAsync(`${config}${ext}`)))
+        const { readFile } = await import("fs/promises");
+        const results = await Promise.all(Object.values(SSR_SITE_CONFIG)
+            .map((config) => [".js", ".cjs", ".mjs", ".ts"].map(async (ext) => {
+            const exists = await existsAsync(`${config}${ext}`);
+            if (exists && config === "vite.config") {
+                const content = await readFile(`${config}${ext}`);
+                return content.includes("solid-start");
+            }
+            return exists;
+        }))
             .flat());
         return results.some(Boolean);
     }
     async function bindSite(reason) {
         // Get metadata
-        const metadata = (reason === "init" ? initialMetadata : await getSiteMetadata());
+        const siteMetadata = (reason === "init"
+            ? initialMetadata
+            : await getSiteMetadataUntilAvailable());
+        const siteConfig = await parseSiteConfig(siteMetadata);
         // Handle rebind due to metadata updated
         if (reason === "metadata_updated") {
-            if (areEnvsSame(metadata.envs, metadataCache?.envs || {}))
+            if (areEnvsSame(siteConfig.envs, siteConfigCache?.envs || {}))
                 return;
             Colors.line(`\n`, `SST resources have been updated. Restarting \`${command}\`...`);
         }
-        metadataCache = metadata;
+        siteConfigCache = siteConfig;
         // Assume function's role credentials
-        if (metadata.role) {
-            const credentials = await assumeSsrRole(metadata.role);
+        if (siteConfig.role) {
+            const credentials = await assumeSsrRole(siteConfig.role);
             if (credentials) {
                 // refresh crecentials 1 minute before expiration
                 const expireAt = credentials.Expiration.getTime() - 60000;
@@ -80,7 +92,7 @@ export const bind = (program) => program
                     bindSite("iam_expired");
                 }, expireAt - Date.now());
                 runCommand({
-                    ...metadata.envs,
+                    ...siteConfig.envs,
                     AWS_ACCESS_KEY_ID: credentials.AccessKeyId,
                     AWS_SECRET_ACCESS_KEY: credentials.SecretAccessKey,
                     AWS_SESSION_TOKEN: credentials.SessionToken,
@@ -90,7 +102,7 @@ export const bind = (program) => program
         }
         // Fallback to use local IAM credentials
         runCommand({
-            ...metadata.envs,
+            ...siteConfig.envs,
             ...(await localIamCredentials()),
         });
     }
@@ -101,24 +113,30 @@ export const bind = (program) => program
             ...(await localIamCredentials()),
         });
     }
-    async function getSiteMetadata() {
-        const { metadata } = await import("../../stacks/metadata.js");
-        const { createSpinner } = await import("../spinner.js");
+    async function parseSiteConfig(metadata) {
         const { LambdaClient, GetFunctionCommand } = await import("@aws-sdk/client-lambda");
         const { useAWSClient } = await import("../../credentials.js");
+        const isBindSupported = metadata.type !== "StaticSite" && metadata.type !== "SlsNextjsSite";
+        // Handle StaticSite
+        if (!isBindSupported) {
+            return { envs: metadata.data.environment };
+        }
+        // Get function details
+        const lambda = useAWSClient(LambdaClient);
+        const { Configuration: functionConfig } = await lambda.send(new GetFunctionCommand({
+            FunctionName: metadata.data.server,
+        }));
+        return {
+            role: functionConfig?.Role,
+            envs: functionConfig?.Environment?.Variables || {},
+            secrets: metadata.data.secrets,
+        };
+    }
+    async function getSiteMetadataUntilAvailable() {
+        const { createSpinner } = await import("../spinner.js");
         const spinner = createSpinner({});
         while (true) {
-            const metadataData = await metadata();
-            const data = Object.values(metadataData)
-                .flat()
-                .filter((c) => Boolean(c))
-                .filter((c) => Boolean(SITE_CONFIG[c.type]))
-                .find((c) => path.resolve(project.paths.root, c.data.path) ===
-                process.cwd());
-            // Do not retry if not running in frontend
-            if (!data && !isFrontend) {
-                return;
-            }
+            const data = await getSiteMetadata();
             // Handle site metadata not found
             if (!data) {
                 spinner.start(
@@ -137,25 +155,20 @@ export const bind = (program) => program
                 continue;
             }
             spinner.isSpinning && spinner.stop().clear();
-            // Handle StaticSite
-            if (!isBindSupported) {
-                return { envs: data.data.environment };
-            }
-            // Get function details
-            const lambda = useAWSClient(LambdaClient);
-            const { Configuration: functionConfig } = await lambda.send(new GetFunctionCommand({
-                FunctionName: data.data.server,
-            }));
-            return {
-                role: functionConfig?.Role,
-                envs: functionConfig?.Environment?.Variables || {},
-                secrets: data.data.secrets,
-            };
+            return data;
         }
     }
+    async function getSiteMetadata() {
+        const { metadata } = await import("../../stacks/metadata.js");
+        const metadataData = await metadata();
+        return Object.values(metadataData)
+            .flat()
+            .filter((c) => Boolean(c))
+            .filter((c) => c.type === "StaticSite" || Boolean(SSR_SITE_CONFIG[c.type]))
+            .find((c) => path.resolve(project.paths.root, c.data.path) === process.cwd());
+    }
     async function assumeSsrRole(roleArn) {
         const { STSClient, AssumeRoleCommand } = await import("@aws-sdk/client-sts");
-        const { Logger } = await import("../../logger.js");
         const { useAWSClient } = await import("../../credentials.js");
         const sts = useAWSClient(STSClient);
         const assumeRole = async (duration) => {
@@ -184,7 +197,7 @@ export const bind = (program) => program
                 err = e;
             }
         }
-        Colors.line(Colors.warning(`Failed to assume SSR role ${roleArn}. Falling back to using local IAM credentials.`));
+        Colors.line("Using local IAM credentials since `sst dev` is not running.");
         Logger.debug(`Failed to assume ${roleArn}.`, err);
     }
     async function localIamCredentials() {

package/cli/commands/plugins/kysely.js

@@ -10,10 +10,11 @@ import { useAWSClient, } from "../../../credentials.js";
 export const useKyselyTypeGenerator = Context.memo(async () => {
     let databases = [];
     const bus = useBus();
+    const logger = Logger.debug.bind(null, "[kysely-codegen]");
     async function generate(db) {
         if (!db.types)
             return;
-        Logger.debug("Generating types for", db.migratorID);
+        logger("generating types for", db.migratorID);
         const k = new Kysely({
             dialect: new DataApiDialect({
                 mode: db.engine.includes("postgres") ? "postgres" : "mysql",
@@ -26,6 +27,7 @@ export const useKyselyTypeGenerator = Context.memo(async () => {
             }),
         });
         const tables = await k.introspection.getTables();
+        logger("introspected tables");
         const metadata = db.engine.includes("postgres")
             ? tables.map((table) => ({
                 ...table,
@@ -46,6 +48,7 @@ export const useKyselyTypeGenerator = Context.memo(async () => {
                     enumValues: null,
                 })),
             }));
+        logger("generated metadata", metadata.length);
         const transformer = new Transformer();
         const Dialect = db.engine.includes("postgres")
             ? new PostgresDialect()
@@ -55,6 +58,7 @@ export const useKyselyTypeGenerator = Context.memo(async () => {
             camelCase: db.types.camelCase === true,
             metadata: new DatabaseMetadata(metadata, new EnumCollection()),
         });
+        logger("transformed nodes", nodes.length);
         const lastIndex = nodes.length - 1;
         const last = nodes[lastIndex];
         nodes[lastIndex] = {
@@ -82,7 +86,9 @@ export const useKyselyTypeGenerator = Context.memo(async () => {
             defaultDatabaseName: c.data.defaultDatabaseName,
             secretArn: c.data.secretArn,
         }));
-        databases.map((db) => generate(db).catch(() => { }));
+        databases.map((db) => generate(db).catch((err) => {
+            logger(err);
+        }));
     });
     bus.subscribe("function.success", async (evt) => {
         if (!evt.properties.body?.results)
@@ -90,7 +96,9 @@ export const useKyselyTypeGenerator = Context.memo(async () => {
         const db = databases.find((db) => db.migratorID === evt.properties.functionID);
         if (!db)
             return;
-        generate(db).catch(() => { });
+        generate(db).catch((err) => {
+            logger(err);
+        });
     });
-    Logger.debug("Loaded kyseley type generator");
+    logger("Loaded kyseley type generator");
 });

package/constructs/NextjsSite.js

@@ -26,7 +26,7 @@ const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 export class NextjsSite extends SsrSite {
     constructor(scope, id, props) {
         super(scope, id, {
-            buildCommand: "npx --yes open-next@latest build",
+            buildCommand: "npx --yes open-next@^0.8.0 build",
             ...props,
         });
     }

package/node/actor/index.d.ts

@@ -0,0 +1,29 @@
+import { SSTError } from "../../util/error.js";
+interface Definition {
+    type: string;
+    properties: Record<string, any>;
+}
+export declare class WrongActorError extends SSTError {
+}
+export declare function createActors<T extends Definition>(): {
+    useActor: () => T | {
+        type: "public";
+        properties: {};
+    };
+    provideActor: (value: T | {
+        type: "public";
+        properties: {};
+    }) => void;
+    assertActor<T_1 extends (T | {
+        type: "public";
+        properties: {};
+    })["type"]>(type: T_1): (Extract<T, {
+        type: T_1;
+    }> | Extract<{
+        type: "public";
+        properties: {};
+    }, {
+        type: T_1;
+    }>)["properties"];
+};
+export {};

package/node/actor/index.js

@@ -0,0 +1,17 @@
+import { Context } from "../../context/context.js";
+import { SSTError } from "../../util/error.js";
+export class WrongActorError extends SSTError {
+}
+export function createActors() {
+    const ctx = Context.create();
+    return {
+        useActor: ctx.use,
+        provideActor: ctx.provide,
+        assertActor(type) {
+            const actor = ctx.use();
+            if (actor.type === type)
+                return actor.properties;
+            throw new WrongActorError(`Expected actor type "${type} but got "${actor.type}"`);
+        },
+    };
+}

package/node/util/index.js

@@ -9,7 +9,10 @@ const ssm = new SSMClient({ region: process.env.SST_REGION });
 //   }
 // }
 let allVariables = {};
-await parseEnvironment();
+// NOTE: in some setups, top level await must be assigned to a variable,
+//       otherwise it would throw a top level await error.
+//       https://discord.com/channels/983865673656705025/1089184080534446110
+const _placeholder = await parseEnvironment();
 export function createProxy(constructName) {
     return new Proxy({}, {
         get(target, prop) {
@@ -87,6 +90,14 @@ async function fetchValuesFromSSM(variablesFromSsm) {
         const variable = parseSsmFallbackPath(item.Name);
         storeVariable(variable, item.Value);
     });
+    // Throw error if any values are missing
+    const missingSecrets = fallbackResults.invalidParams
+        .map((name) => parseSsmFallbackPath(name))
+        .filter((variable) => variable.constructName === "Secret")
+        .map((variable) => variable.constructId);
+    if (missingSecrets.length > 0) {
+        throw new Error(`The following secrets were not found: ${missingSecrets.join(", ")}`);
+    }
 }
 async function loadSecrets(paths) {
     // Split paths into chunks of 10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sst",
-  "version": "2.4.0",
+  "version": "2.4.2",
   "bin": {
     "sst": "cli/sst.js"
   },

package/runtime/handlers/go.js

@@ -1,5 +1,6 @@
 import path from "path";
 import fs from "fs/promises";
+import os from "os";
 import { useRuntimeHandlers } from "../handlers.js";
 import { useRuntimeWorkers } from "../workers.js";
 import { Context } from "../../context/context.js";
@@ -57,7 +58,8 @@ export const useGoHandler = Context.memo(async () => {
             if (input.mode === "start") {
                 try {
                     const target = path.join(input.out, handlerName);
-                    const result = await execAsync(`go build -ldflags '-s -w' -o '${target}' ./${src}`, {
+                    const srcPath = os.platform() === "win32" ? src.replaceAll("\\", "\\\\") : src;
+                    const result = await execAsync(`go build -ldflags "-s -w" -o "${target}" ./${srcPath}`, {
                         cwd: project,
                         env: {
                             ...process.env,
@@ -71,7 +73,8 @@ export const useGoHandler = Context.memo(async () => {
             if (input.mode === "deploy") {
                 try {
                     const target = path.join(input.out, "bootstrap");
-                    await execAsync(`go build -ldflags '-s -w' -o '${target}' ./${src}`, {
+                    const srcPath = os.platform() === "win32" ? src.replaceAll("\\", "\\\\") : src;
+                    await execAsync(`go build -ldflags "-s -w" -o "${target}" ./${srcPath}`, {
                         cwd: project,
                         env: {
                             ...process.env,
@@ -81,8 +84,8 @@ export const useGoHandler = Context.memo(async () => {
                         },
                     });
                 }
-                catch {
-                    throw new VisibleError("Failed to build");
+                catch (ex) {
+                    throw new VisibleError(`Failed to build ${ex}`);
                 }
             }
             return {