sst 2.38.3 → 2.38.4

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/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/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());

package/package.json

@@ -1,7 +1,7 @@
 {
   "sideEffects": false,
   "name": "sst",
-  "version": "2.38.3",
+  "version": "2.38.4",
   "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.4",
     "async": "^3.2.4",
     "tsx": "^3.12.1",
     "typescript": "^5.2.2",

package/runtime/handlers/node.js

@@ -206,9 +206,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) => {