sst 2.38.3 → 2.38.5

package/cli/commands/bind.js

@@ -21,7 +21,7 @@ export const bind = (program) => program
     const { useProject } = await import("../../project.js");
     const { Stacks } = await import("../../stacks/index.js");
     const { useBus } = await import("../../bus.js");
-    const { useIOT } = await import("../../iot.js");
+    const { useIOT, isSupported } = await import("../../iot.js");
     const { Colors } = await import("../colors.js");
     const { Logger } = await import("../../logger.js");
     const [{ useServices }, { useSites: useSsrSites }, { useSites: useStaticSites }, { useSites: useSlsNextjsSites }, { Parameter }, { getEnvironmentKey },] = await Promise.all([
@@ -42,7 +42,9 @@ export const bind = (program) => program
         if (!command) {
             throw new VisibleError("Command is required, e.g. sst bind npm run script");
         }
-        useIOT();
+        if (isSupported()) {
+            useIOT();
+        }
         const bus = useBus();
         const project = useProject();
         let p;

package/cli/commands/dev.js

@@ -1,3 +1,4 @@
+import { VisibleError } from "../../error.js";
 export const dev = (program) => program.command(["dev", "start"], "Work on your app locally", (yargs) => yargs.option("increase-timeout", {
     type: "boolean",
     description: "Increase function timeout",
@@ -20,11 +21,15 @@ export const dev = (program) => program.command(["dev", "start"], "Work on your
     const { getCiInfo } = await import("../ci-info.js");
     const { useMetadataCache } = await import("../../stacks/metadata.js");
     const { lazy } = await import("../../util/lazy.js");
+    const { useIOT, isSupported } = await import("../../iot.js");
     try {
         if (args._[0] === "start") {
             console.log(yellow(`Warning: ${bold(`sst start`)} has been renamed to ${bold(`sst dev`)}`));
         }
         const project = useProject();
+        if (!isSupported()) {
+            throw new VisibleError(`Live Lambda is not currently supported in the "${project.config.region}" region. To fix this, you can pick an alternative region just for your local environment - https://docs.sst.dev/live-lambda-development#supported-regions`);
+        }
         const useFunctionLogger = lazy(async () => {
             const { useFunctions } = await import("../../constructs/Function.js");
             const bus = useBus();
@@ -296,7 +301,7 @@ export const dev = (program) => program.command(["dev", "start"], "Work on your
         });
         const useDisconnector = lazy(async () => {
             const bus = useBus();
-            const iot = await import("../../iot.js").then((mod) => mod.useIOT());
+            const iot = await useIOT();
             bus.subscribe("cli.dev", async (evt) => {
                 const topic = `${iot.prefix}/events`;
                 iot.publish(topic, "cli.dev", evt.properties);

package/constructs/AstroSite.js

@@ -2,6 +2,7 @@ import { readFileSync, existsSync, readdirSync, statSync } from "fs";
 import { join } from "path";
 import { SsrSite, } from "./SsrSite.js";
 import { AllowedMethods } from "aws-cdk-lib/aws-cloudfront";
+import { getStringifiedRouteTree } from "./util/astroRouteCompressor.js";
 const BUILD_META_FILE_NAME = "sst.buildMeta.json";
 /**
  * The `AstroSite` construct is a higher level CDK construct that makes it easy to create a Astro app.
@@ -28,40 +29,30 @@ export class AstroSite extends SsrSite {
         return JSON.parse(readFileSync(filePath, "utf-8"));
     }
     static getCFRoutingFunction({ routes, pageResolution, }) {
-        const serializedRoutes = routes.map((route) => ({
-            rt: route.route,
-            pt: new RegExp(route.pattern),
-            t: route.type[1],
-            pr: route.prerender === true ? true : undefined,
-            rp: route.redirectPath,
-            rs: route.redirectStatus,
-        }));
-        function objectToString(obj) {
-            return `{ ${Object.entries(obj)
-                .filter(([_, value]) => value !== undefined)
-                .map(([key, value]) => `${key}: ${typeof value === "string" ? `'${value}'` : value}`)
-                .join(", ")} }`;
-        }
         return `
-  var routes = [${serializedRoutes.map(objectToString).join(", ")}]
-  var match = routes.find((route) => route.pt.test(request.uri));
-  if (match) {
-    if (match.t === "r") {
-      var redirectPath = match.rp;
-      (match.pt.exec(request.uri) || []).forEach((match, index) => {
-        redirectPath = redirectPath.replace(\`\\\${\${index}}\`, match)
+  var routeData = ${getStringifiedRouteTree(routes)};
+  var findMatch = (path, routeData) => {
+    var match = routeData.find((route) => route[0].test(path));
+    return match && Array.isArray(match[1]) ? findMatch(path, match[1]) : match;
+  };
+    
+  var matchedRoute = findMatch(request.uri, routeData);
+  if (matchedRoute) {
+    if (!matchedRoute[1]) {
+      ${pageResolution === "file"
+            ? `request.uri = request.uri === "/" ? "/index.html" : request.uri.replace(/\\/?$/, ".html");`
+            : `request.uri = request.uri.replace(/\\/?$/, "/index.html");`}
+    } else if (matchedRoute[1] === 2) {
+      var redirectPath = matchedRoute[2];
+      matchedRoute[0].exec(request.uri).forEach((match, index) => {
+        redirectPath = redirectPath.replace(\`\\\${\${index}}\`, match);
       });
       return {
-        statusCode: match.rs || 308,
+        statusCode: matchedRoute[3] || 308,
         headers: { location: { value: redirectPath } },
       };
-    } else if (match.t === "p" && match.pr) {
-      ${pageResolution === "file"
-            ? `request.uri = request.uri === "/" ? "/index.html" : request.uri.replace(/\\/?$/, ".html");`
-            : `request.uri = request.uri.replace(/\\/?$/, "/index.html");`}
     }
-  }
-`;
+  }`;
     }
     plan() {
         const { path: sitePath } = this.props;

package/constructs/Function.js

@@ -151,6 +151,7 @@ export class Function extends CDKFunction {
                 ...props,
                 ...(props.runtime === "container"
                     ? {
+                        description: "SST Live Lambda handler",
                         code: Code.fromAssetImage(path.resolve(__dirname, "../support/bridge"), {
                             ...(architecture?.dockerPlatform
                                 ? { platform: Platform.custom(architecture.dockerPlatform) }
@@ -161,9 +162,10 @@ export class Function extends CDKFunction {
                         layers: undefined,
                     }
                     : {
+                        description: "SST Live Lambda handler",
                         runtime: CDKRuntime.NODEJS_18_X,
                         code: Code.fromAsset(path.resolve(__dirname, "../support/bridge")),
-                        handler: "bridge.handler",
+                        handler: "live-lambda.handler",
                         layers: [],
                     }),
                 architecture,

package/constructs/SsrSite.js

@@ -30,6 +30,7 @@ import { getParameterPath, } from "./util/functionBinding.js";
 import { useProject } from "../project.js";
 import { VisibleError } from "../error.js";
 import { RetentionDays } from "aws-cdk-lib/aws-logs";
+import { transformSync } from "esbuild";
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 /**
  * The `SsrSite` construct is a higher level CDK construct that makes it easy to create modern web apps with Server Side Rendering capabilities.
@@ -371,13 +372,18 @@ export class SsrSite extends Construct {
         function createCloudFrontFunctions() {
             const functions = {};
             Object.entries(plan.cloudFrontFunctions ?? {}).forEach(([name, { constructId, injections }]) => {
-                functions[name] = new CfFunction(self, constructId, {
-                    code: CfFunctionCode.fromInline(`
+                const rawCode = `
 function handler(event) {
   var request = event.request;
   ${injections.join("\n")}
   return request;
-}`),
+}`;
+                const minifiedCode = transformSync(rawCode, {
+                    minify: true,
+                    target: "es5",
+                });
+                functions[name] = new CfFunction(self, constructId, {
+                    code: CfFunctionCode.fromInline(minifiedCode.code),
                 });
             });
             return functions;

package/constructs/util/astroRouteCompressor.d.ts

@@ -0,0 +1,10 @@
+import type { BuildMetaConfig } from "astro-sst/build-meta";
+type TreeNode = {
+    branches: Record<string, TreeNode>;
+    nodes: BuildMetaConfig["routes"][number][];
+};
+type FlattenedRoute = [string] | [string, 1] | [string, 2, string | undefined, number | undefined];
+type FlattenedRouteTree = Array<FlattenedRoute | [string, FlattenedRouteTree]>;
+export declare function flattenRouteTree(tree: TreeNode, parentKey?: string): FlattenedRouteTree;
+export declare function getStringifiedRouteTree(routes: BuildMetaConfig["routes"]): string;
+export {};

package/constructs/util/astroRouteCompressor.js

@@ -0,0 +1,75 @@
+function buildRouteTree(routes, level = 0) {
+    const routeTree = routes.reduce((tree, route) => {
+        const routePatternWithoutCaptureGroups = route.pattern
+            .replace(/\((?:\?:)?(.*?[^\\])\)/g, (_, content) => content.trim())
+            .replace(/\/\^/g, "")
+            .replace(/\$\//g, "");
+        const routeParts = routePatternWithoutCaptureGroups
+            .split(/(?=\\\/)/g)
+            .filter((part) => part !== "/^" && part !== "/$/");
+        tree.branches[routeParts[level]] = tree.branches[routeParts[level]] || {
+            branches: {},
+            nodes: [],
+        };
+        tree.branches[routeParts[level]].nodes.push(route);
+        return tree;
+    }, { branches: {}, nodes: [] });
+    for (const [key, branch] of Object.entries(routeTree.branches)) {
+        if (!branch.nodes.some((node) => node.prerender || node.type === "redirect")) {
+            delete routeTree.branches[key];
+        }
+        else if (branch.nodes.length > 1) {
+            routeTree.branches[key] = buildRouteTree(branch.nodes, level + 1);
+            branch.nodes = [];
+        }
+    }
+    return routeTree;
+}
+export function flattenRouteTree(tree, parentKey = "") {
+    const flatTree = [];
+    for (const [key, branch] of Object.entries(tree.branches)) {
+        if (branch.nodes.length === 1) {
+            const node = branch.nodes[0];
+            if (node.type === "page") {
+                flatTree.push([node.pattern]);
+            }
+            if (node.type === "endpoint") {
+                flatTree.push([node.pattern, 1]);
+            }
+            else if (node.type === "redirect") {
+                flatTree.push([
+                    node.pattern,
+                    2,
+                    node.redirectPath,
+                    node.redirectStatus,
+                ]);
+            }
+        }
+        else {
+            const flatKey = parentKey + key;
+            flatTree.push([flatKey, flattenRouteTree(branch, flatKey)]);
+        }
+    }
+    return flatTree;
+}
+function stringifyFlattenedRouteTree(tree) {
+    return `[${tree
+        .map((tuple) => {
+        if (Array.isArray(tuple[1])) {
+            return `[/^${tuple[0]}/,${stringifyFlattenedRouteTree(tuple[1])}]`;
+        }
+        if (typeof tuple[1] === "undefined") {
+            return `[${tuple[0]}]`;
+        }
+        else if (tuple[1] === 1) {
+            return `[${tuple[0]},1]`;
+        }
+        return `[${tuple[0]},2,"${tuple[2]}"${tuple[3] ? `,${tuple[3]}` : ""}]`;
+    })
+        .join(",")}]`;
+}
+export function getStringifiedRouteTree(routes) {
+    const tree = buildRouteTree(routes);
+    const flatTree = flattenRouteTree(tree);
+    return stringifyFlattenedRouteTree(flatTree);
+}

package/credentials.js

@@ -53,10 +53,22 @@ export function useAWSClient(client, force = false) {
     const [project, credentials] = [useProject(), useAWSCredentialsProvider()];
     const printNoInternet = (() => {
         let lastPrinted = 0;
-        return () => {
+        return (message) => {
+            const isIotUnreachable = message.includes(`iot.${project.config.region}.amazonaws.com`);
             const now = Date.now();
             if (now - lastPrinted > 5000) {
-                console.log("Waiting for internet connection...");
+                if (isIotUnreachable) {
+                    console.log("\nConnecting to Live Lambda...");
+                    if (lastPrinted === 0) {
+                        console.log("");
+                        console.log("Connecting to Live Lambda is taking long:");
+                        console.log("  - Check if your machine is able to connect to AWS.");
+                        console.log("  - Or, if you're connecting to a new AWS account for the first time, give it 10 minutes.");
+                    }
+                }
+                else {
+                    console.log("\nWaiting for internet connection...");
+                }
                 lastPrinted = now;
             }
         };
@@ -68,7 +80,7 @@ export function useAWSClient(client, force = false) {
             retryDecider: (e) => {
                 // Handle no internet connection => retry
                 if (e.code === "ENOTFOUND") {
-                    printNoInternet();
+                    printNoInternet(e.message);
                     return true;
                 }
                 // Handle throttling errors => retry

package/iot.d.ts

@@ -4,3 +4,4 @@ export declare const useIOT: () => Promise<{
     prefix: string;
     publish<Type extends keyof Events>(topic: string, type: Type, properties: Events[Type]): Promise<void>;
 }>;
+export declare const isSupported: () => boolean;

package/iot.js

@@ -114,7 +114,7 @@ export const useIOT = lazy(async () => {
         Logger.debug("IoT closed");
     });
     device.on("reconnect", () => {
-        Logger.debug("IoT reconnected");
+        Logger.debug("IoT reconnecting...");
     });
     device.on("message", (_topic, buffer) => {
         const fragment = JSON.parse(buffer.toString());
@@ -161,3 +161,28 @@ export const useIOT = lazy(async () => {
         },
     };
 });
+export const isSupported = () => [
+    "eu-central-1",
+    "eu-west-1",
+    "eu-west-2",
+    "eu-west-3",
+    "eu-north-1",
+    "ap-south-1",
+    "ap-northeast-2",
+    "ap-northeast-1",
+    "me-south-1",
+    "me-central-1",
+    "sa-east-1",
+    "ca-central-1",
+    "ap-east-1",
+    "ap-southeast-1",
+    "ap-southeast-2",
+    "us-east-1",
+    "us-east-2",
+    "us-west-1",
+    "us-west-2",
+    "us-gov-east-1",
+    "us-gov-west-1",
+    "cn-north-1",
+    "cn-northwest-1",
+].includes(useProject().config.region);

package/package.json

@@ -1,7 +1,7 @@
 {
   "sideEffects": false,
   "name": "sst",
-  "version": "2.38.3",
+  "version": "2.38.5",
   "bin": {
     "sst": "cli/sst.js"
   },
@@ -120,7 +120,7 @@
     "@types/ws": "^8.5.3",
     "@types/yargs": "^17.0.13",
     "archiver": "^5.3.1",
-    "astro-sst": "2.38.3",
+    "astro-sst": "2.38.5",
     "async": "^3.2.4",
     "tsx": "^3.12.1",
     "typescript": "^5.2.2",

package/runtime/handlers/container.js

@@ -1,3 +1,5 @@
+import process from "process";
+import { release, networkInterfaces } from "os";
 import http from "http";
 import { spawn } from "child_process";
 import { useRuntimeWorkers } from "../workers.js";
@@ -50,10 +52,11 @@ export const useContainerHandler = () => {
         const server = await useRuntimeServerConfig();
         const workers = await useRuntimeWorkers();
         const fn = useFunctions().fromID(input.functionID);
+        const host = isWSL() ? getInternalHost() : "host.docker.internal";
         dockerRun(input, {
             cmd: fn?.container?.cmd,
             envs: {
-                AWS_LAMBDA_RUNTIME_API: `host.docker.internal:${server.port}/${input.workerID}`,
+                AWS_LAMBDA_RUNTIME_API: `${host}:${server.port}/${input.workerID}`,
             },
         }, () => {
             workers.exited(input.workerID);
@@ -261,3 +264,12 @@ export const useContainerHandler = () => {
         },
     };
 };
+function isWSL() {
+    return (process.platform == "linux" && release().toLowerCase().includes("microsoft"));
+}
+function getInternalHost() {
+    const host = []
+        .concat(...Object.values(networkInterfaces()))
+        .find((x) => !x?.internal && x?.family === "IPv4")?.address;
+    return host ?? "host.docker.internal";
+}

package/runtime/handlers/node.js

@@ -87,7 +87,9 @@ export const useNodeHandler = () => {
             const extension = isESM ? ".mjs" : ".cjs";
             const target = path.join(input.out, !relative.startsWith("..") && !path.isAbsolute(input.props.handler)
                 ? relative
-                : "", parsed.name + extension);
+                : "", 
+            // Lambda handler can only contain 1 dot separating the file name and function name
+            parsed.name.replace(".", "-") + extension);
             const handler = path
                 .relative(input.out, target.replace(extension, parsed.ext))
                 .split(path.sep)
@@ -206,9 +208,25 @@ export const useNodeHandler = () => {
                     }));
                     const cmd = ["npm install"];
                     if (installPackages.includes("sharp")) {
-                        cmd.push("--platform=linux", input.props.architecture === "arm_64"
+                        /**
+                         * TODO: This is a workaround for issues that sharp v0.33.0 has
+                         * with cross platform builds. This can be removed once sharp
+                         * releases a new version with the fix.
+                         */
+                        cmd.push("--platform=linux", "--omit=dev", "--no-optional", input.props.architecture === "arm_64"
                             ? "--arch=arm64"
-                            : "--arch=x64");
+                            : "--arch=x64", "--force sharp@0.32.6");
+                        /**
+                         * Once the above issue is resolved, the code below can be used.
+                         */
+                        // cmd.push(
+                        //   "--platform=linux",
+                        //   "--omit=dev",
+                        //   "--no-optional",
+                        //   ...input.props.architecture === "arm_64"
+                        //     ? ["--arch=arm64", "--force @img/sharp-linux-arm64"]
+                        //     : ["--arch=x64", "--force @img/sharp-linux-x64"],
+                        // );
                     }
                     await new Promise((resolve, reject) => {
                         exec(cmd.join(" "), { cwd: input.out }, (error) => {

package/support/bridge/Dockerfile

@@ -1,3 +1,3 @@
 FROM public.ecr.aws/lambda/nodejs:18
-COPY bridge.mjs ${LAMBDA_TASK_ROOT}
-CMD ["bridge.handler"]
+COPY live-lambda.mjs ${LAMBDA_TASK_ROOT}
+CMD ["live-lambda.handler"]

package/util/wsl.d.ts

@@ -0,0 +1,2 @@
+export declare const isWSL: () => boolean;
+export declare const getInternalHost: () => string | undefined;

package/util/wsl.js

@@ -0,0 +1,10 @@
+import process from "process";
+import { release, networkInterfaces } from "os";
+export const isWSL = () => {
+    return (process.platform == "linux" && release().toLowerCase().includes("microsoft"));
+};
+export const getInternalHost = () => {
+    return []
+        .concat(...Object.values(networkInterfaces()))
+        .find((x) => !x?.internal && x?.family === "IPv4")?.address;
+};