sst 2.36.7 → 2.37.0

package/constructs/AstroSite.js

@@ -28,38 +28,40 @@ export class AstroSite extends SsrSite {
         return JSON.parse(readFileSync(filePath, "utf-8"));
     }
     static getCFRoutingFunction({ routes, pageResolution, }) {
-        const serializedRoutes = "[\n" +
-            routes
-                .map((route) => {
-                return `    {route: "${route.route}", pattern: ${route.pattern}, type: "${route.type}", ${typeof route.prerender !== "undefined"
-                    ? `prerender: ${route.prerender}, `
-                    : ``}${route.redirectPath ? `redirectPath: "${route.redirectPath}", ` : ""}${route.redirectStatus
-                    ? `redirectStatus: ${route.redirectStatus}`
-                    : ""} }`;
-            })
-                .join(",\n") +
-            "\n  ]";
-        return `  // AstroSite CF Routing Function
-  var astroRoutes = ${serializedRoutes};
-  var matchedRoute = astroRoutes.find((route) => route.pattern.test(request.uri));
-  if (matchedRoute) {
-    if (matchedRoute.type === "redirect") {
-      var redirectPath = matchedRoute.redirectPath;
-      matchedRoute.pattern.exec(request.uri).forEach((match, index) => {
-        redirectPath = redirectPath.replace(\`\\\${\${index}}\`, match);
+        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 statusCode = matchedRoute.redirectStatus || 308;
       return {
-        statusCode,
+        statusCode: match.rs || 308,
         headers: { location: { value: redirectPath } },
       };
-    } else if (matchedRoute.type === "page" && matchedRoute.prerender) {
+    } 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");`}
     }
   }
-  // End AstroSite CF Routing Function`;
+`;
     }
     plan() {
         const { path: sitePath } = this.props;

package/constructs/RDS.js

@@ -357,6 +357,7 @@ export class RDS extends Construct {
             nodir: true,
             follow: true,
             cwd: migrations,
+            ignore: ["**/node_modules/**"],
         });
         // Calculate hash of all files content
         return crypto

package/constructs/future/Auth.js

@@ -117,6 +117,10 @@ export class Auth extends Construct {
                     type: "plain",
                     value: this.url,
                 },
+                authId: {
+                    type: "auth_id",
+                    value: this.id,
+                },
             },
             permissions: {},
         };

package/constructs/util/functionBinding.d.ts

@@ -14,6 +14,9 @@ export interface FunctionBindingProps {
     } | {
         type: "site_url";
         value: string;
+    } | {
+        type: "auth_id";
+        value: string;
     }>;
 }
 export declare function bindEnvironment(c: SSTConstruct): Record<string, string>;

package/constructs/util/functionBinding.js

@@ -15,6 +15,9 @@ export function bindEnvironment(c) {
             else if (variable.type === "secret_reference") {
                 environment[envName] = placeholderSecretReferenceValue(variable.secret);
             }
+            else if (variable.type === "auth_id") {
+                environment["AUTH_ID"] = variable.value;
+            }
         });
     }
     return environment;

package/context/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./context.js";
+export { Context } from "./context2.js";
 export * from "./handler.js";

package/context/index.js

@@ -1,2 +1,2 @@
-export * from "./context.js";
+export { Context } from "./context2.js";
 export * from "./handler.js";

package/node/future/auth/adapter/apple.d.ts

@@ -0,0 +1,16 @@
+import { OauthConfig } from "./oauth.js";
+export declare const AppleAdapter: (config: OauthConfig) => () => Promise<{
+    type: "success";
+    properties: {
+        tokenset: import("openid-client").TokenSet;
+        client: import("openid-client").BaseClient;
+    };
+} | {
+    type: "step";
+    properties: {
+        statusCode: number;
+        headers: {
+            location: string;
+        };
+    };
+} | undefined>;

package/node/future/auth/adapter/apple.js

@@ -0,0 +1,80 @@
+import { generators, Issuer } from "openid-client";
+import { useBody, useCookie, useDomainName, usePathParam, useResponse, } from "../../../api/index.js";
+const querystring = require("querystring");
+// This adapter support the OAuth flow with the response_mode "form_post" for now.
+// More details about the flow:
+// https://developer.apple.com/documentation/devicemanagement/user_enrollment/onboarding_users_with_account_sign-in/implementing_the_oauth2_authentication_user-enrollment_flow
+//
+// Also note that Apple's discover uri does not work for the OAuth flow, as the
+// userinfo_endpoint are not included in the response.
+// await Issuer.discover("https://appleid.apple.com/.well-known/openid-configuration/");
+const issuer = await Issuer.discover("https://appleid.apple.com/.well-known/openid-configuration");
+export const AppleAdapter = 
+/* @__PURE__ */
+(config) => {
+    return async function () {
+        const step = usePathParam("step");
+        const callback = "https://" + useDomainName() + "/callback";
+        console.log("callback", callback);
+        const client = new issuer.Client({
+            client_id: config.clientID,
+            client_secret: config.clientSecret,
+            redirect_uris: [callback],
+            response_types: ["code"],
+        });
+        if (step === "authorize" || step === "connect") {
+            const code_verifier = generators.codeVerifier();
+            const state = generators.state();
+            const code_challenge = generators.codeChallenge(code_verifier);
+            const url = client.authorizationUrl({
+                scope: config.scope,
+                code_challenge: code_challenge,
+                code_challenge_method: "S256",
+                state,
+                prompt: config.prompt,
+                ...config.params,
+            });
+            useResponse().cookies({
+                auth_code_verifier: code_verifier,
+                auth_state: state,
+            }, {
+                httpOnly: true,
+                secure: true,
+                maxAge: 60 * 10,
+                sameSite: "None",
+            });
+            return {
+                type: "step",
+                properties: {
+                    statusCode: 302,
+                    headers: {
+                        location: url,
+                    },
+                },
+            };
+        }
+        if (step === "callback") {
+            let params;
+            if (config &&
+                config.params &&
+                config.params.response_mode === "form_post") {
+                const body = useBody();
+                params = querystring.parse(body);
+            }
+            const code_verifier = useCookie("auth_code_verifier");
+            const state = useCookie("auth_state");
+            const tokenset = await client["callback"](callback, params, {
+                code_verifier,
+                state,
+            });
+            const x = {
+                type: "success",
+                properties: {
+                    tokenset,
+                    client,
+                },
+            };
+            return x;
+        }
+    };
+};

package/package.json

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

package/support/custom-resources/index.mjs

@@ -154593,7 +154593,8 @@ var handler = (event) => {
   return event.RequestType ? customResourceEventHandler(event) : lambdaEventHandler(event);
 };
 var customResourceEventHandler = wrapper(async (cfnRequest) => {
-  log("Handling custom resource event", cfnRequest);
+  const { ResponseURL, ...other } = cfnRequest;
+  log("Handling custom resource event", other);
   switch (cfnRequest.ResourceType) {
     case "Custom::AuthKeys":
       await AuthKeys(cfnRequest);

package/context/context.d.ts

@@ -1,13 +0,0 @@
-export declare const Context: {
-    create: typeof create;
-    reset: typeof reset;
-    memo: typeof memo;
-};
-declare function create<C>(cb?: (() => C) | string, name?: string): {
-    use(): C;
-    reset(): void;
-    provide(value: C): void;
-};
-declare function reset(): void;
-export declare function memo<C>(cb: () => C, name?: string): () => C;
-export {};

package/context/context.js

@@ -1,69 +0,0 @@
-export const Context = {
-    create,
-    reset,
-    memo,
-};
-const state = {
-    requestID: "",
-    contexts: new Map(),
-    tracking: [],
-};
-function create(cb, name) {
-    const id = typeof cb === "string" ? cb : name || Symbol(cb?.toString());
-    return {
-        use() {
-            let result = state.contexts.get(id);
-            if (!result) {
-                if (!cb || typeof cb === "string")
-                    throw new Error(`"${String(id)}" context was not provided.`);
-                state.tracking.push(id);
-                const value = cb();
-                state.tracking.pop();
-                result = {
-                    value,
-                    dependants: new Set(),
-                };
-                state.contexts.set(id, result);
-            }
-            const last = state.tracking[state.tracking.length - 1];
-            // Use is being called within another context booting up so mark it as a dependent
-            if (last)
-                result.dependants.add(last);
-            return result.value;
-        },
-        reset() {
-            resetDependencies(id);
-            state.contexts.delete(id);
-        },
-        provide(value) {
-            // If a new request has started, automatically clear all contexts
-            const requestID = global[Symbol.for("aws.lambda.runtime.requestId")];
-            if (state.requestID !== requestID) {
-                state.requestID = requestID;
-                reset();
-            }
-            // If the context is already set, we need to reset its dependants
-            resetDependencies(id);
-            state.contexts.set(id, {
-                value,
-                dependants: new Set(),
-            });
-        },
-    };
-}
-function reset() {
-    state.contexts.clear();
-}
-function resetDependencies(id) {
-    const info = state.contexts.get(id);
-    if (!info)
-        return;
-    for (const dependantID of info.dependants) {
-        state.contexts.delete(dependantID);
-        resetDependencies(dependantID);
-    }
-}
-export function memo(cb, name) {
-    const ctx = create(cb, name);
-    return ctx.use;
-}