sst 2.36.8 → 2.37.1

package/constructs/AstroSite.js

@@ -30,26 +30,32 @@ export class AstroSite extends SsrSite {
     static getCFRoutingFunction({ routes, pageResolution, }) {
         const serializedRoutes = routes.map((route) => ({
             rt: route.route,
-            pt: route.pattern,
-            t: route.type,
+            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 = ${JSON.stringify(serializedRoutes)}
-  var match = routes.find((route) => new RegExp(route.pt).test(request.uri));
+  var routes = [${serializedRoutes.map(objectToString).join(", ")}]
+  var match = routes.find((route) => route.pt.test(request.uri));
   if (match) {
-    if (match.t === "redirect") {
+    if (match.t === "r") {
       var redirectPath = match.rp;
-      new RegExp(match.pt).exec(request.uri)?.forEach((match, index) => {
+      (match.pt.exec(request.uri) || []).forEach((match, index) => {
         redirectPath = redirectPath.replace(\`\\\${\${index}}\`, match)
       });
       return {
         statusCode: match.rs || 308,
         headers: { location: { value: redirectPath } },
       };
-    } else if (match.t === "page" && match.pr) {
+    } 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");`}
@@ -125,6 +131,10 @@ export class AstroSite extends SsrSite {
                 });
             }
             else {
+                plan.cloudFrontFunctions.imageServiceCfFunction = {
+                    constructId: "ImageServiceCloudFrontFunction",
+                    injections: [this.useCloudFrontFunctionHostHeaderInjection()],
+                };
                 plan.origins.regionalServer = {
                     type: "function",
                     constructId: "ServerFunction",
@@ -146,6 +156,12 @@ export class AstroSite extends SsrSite {
                     cacheType: "static",
                     pattern: `${buildMeta.clientBuildVersionedSubDir}/*`,
                     origin: "staticsServer",
+                }, {
+                    cacheType: "server",
+                    pattern: "_image",
+                    cfFunction: "imageServiceCfFunction",
+                    origin: "regionalServer",
+                    allowedMethods: AllowedMethods.ALLOW_GET_HEAD_OPTIONS,
                 }, ...buildMeta.serverRoutes?.map((route) => ({
                     cacheType: "server",
                     pattern: route,

package/constructs/Distribution.js

@@ -8,6 +8,7 @@ import { Stack } from "./Stack.js";
 import { isCDKConstruct } from "./Construct.js";
 import { HttpsRedirect } from "./cdk/website-redirect.js";
 import { DnsValidatedCertificate } from "./cdk/dns-validated-certificate.js";
+import { VisibleError } from "../error.js";
 export class Distribution extends Construct {
     scope;
     props;
@@ -108,10 +109,10 @@ export class Distribution extends Construct {
         if (!cdk?.distribution)
             return;
         if (cdk.distribution.certificate) {
-            throw new Error(`Do not configure the "cfDistribution.certificate". Use the "customDomain" to configure the domain certificate.`);
+            throw new VisibleError(`Do not configure the "cfDistribution.certificate". Use the "customDomain" to configure the domain certificate.`);
         }
         if (cdk.distribution.domainNames) {
-            throw new Error(`Do not configure the "cfDistribution.domainNames". Use the "customDomain" to configure the domain name.`);
+            throw new VisibleError(`Do not configure the "cfDistribution.domainNames". Use the "customDomain" to configure the domain name.`);
         }
     }
     validateCustomDomainSettings() {
@@ -122,15 +123,18 @@ export class Distribution extends Construct {
         if (typeof customDomain === "string") {
             return;
         }
+        if (!customDomain.domainName) {
+            throw new VisibleError(`Missing "domainName" for customDomain.`);
+        }
         if (customDomain.isExternalDomain === true) {
             if (!customDomain.cdk?.certificate) {
-                throw new Error(`A valid certificate is required when "isExternalDomain" is set to "true".`);
+                throw new VisibleError(`A valid certificate is required when "isExternalDomain" is set to "true".`);
             }
             if (customDomain.domainAlias) {
-                throw new Error(`Domain alias is only supported for domains hosted on Amazon Route 53. Do not set the "customDomain.domainAlias" when "isExternalDomain" is enabled.`);
+                throw new VisibleError(`Domain alias is only supported for domains hosted on Amazon Route 53. Do not set the "customDomain.domainAlias" when "isExternalDomain" is enabled.`);
             }
             if (customDomain.hostedZone) {
-                throw new Error(`Hosted zones can only be configured for domains hosted on Amazon Route 53. Do not set the "customDomain.hostedZone" when "isExternalDomain" is enabled.`);
+                throw new VisibleError(`Hosted zones can only be configured for domains hosted on Amazon Route 53. Do not set the "customDomain.hostedZone" when "isExternalDomain" is enabled.`);
             }
         }
     }
@@ -223,7 +227,7 @@ export class Distribution extends Construct {
             domainNames.push(customDomain.domainName);
             if (customDomain.alternateNames) {
                 if (!customDomain.cdk?.certificate)
-                    throw new Error("Certificates for alternate domains cannot be automatically created. Please specify certificate to use");
+                    throw new VisibleError("Certificates for alternate domains cannot be automatically created. Please specify certificate to use");
                 domainNames.push(...customDomain.alternateNames);
             }
         }

package/constructs/EdgeFunction.js

@@ -99,6 +99,7 @@ export class EdgeFunction extends Construct {
         const { nodejs } = this.props;
         useFunctions().add(this.node.addr, {
             ...this.props,
+            architecture: "x86_64",
             nodejs: {
                 ...nodejs,
                 banner: [

package/constructs/Function.d.ts

@@ -686,6 +686,8 @@ export declare class Function extends CDKFunction implements SSTConstruct {
     readonly _isLiveDevEnabled: boolean;
     /** @internal */
     readonly _doNotAllowOthersToBind?: boolean;
+    /** @internal */
+    _overrideMetadataHandler?: string;
     private missingSourcemap?;
     private functionUrl?;
     private props;

package/constructs/Function.js

@@ -67,6 +67,8 @@ export class Function extends CDKFunction {
     _isLiveDevEnabled;
     /** @internal */
     _doNotAllowOthersToBind;
+    /** @internal */
+    _overrideMetadataHandler;
     missingSourcemap;
     functionUrl;
     props;
@@ -371,7 +373,7 @@ export class Function extends CDKFunction {
             data: {
                 arn: this.functionArn,
                 runtime: this.props.runtime,
-                handler: this.props.handler,
+                handler: this._overrideMetadataHandler ?? this.props.handler,
                 missingSourcemap: this.missingSourcemap === true ? true : undefined,
                 localId: this.node.addr,
                 secrets: this.allBindings

package/constructs/RDS.js

@@ -312,6 +312,8 @@ export class RDS extends Construct {
             },
             _doNotAllowOthersToBind: true,
         });
+        this.migratorFunction._overrideMetadataHandler =
+            "rds-migrator/index.handler";
     }
     createMigrationCustomResource(migrations) {
         const app = this.node.root;
@@ -357,6 +359,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/Service.d.ts

@@ -65,6 +65,17 @@ export interface ServiceProps {
      *```
      */
     memory?: `${number} GB`;
+    /**
+     * The amount of ephemeral storage allocated, in GB.
+     * @default "20 GB"
+     * @example
+     * ```js
+     * {
+     *   storage: "100 GB",
+     * }
+     * ```
+     */
+    storage?: `${number} GB`;
     /**
      * The port number on the container.
      * @default 3000
@@ -373,6 +384,7 @@ type ServiceNormalizedProps = ServiceProps & {
     cpu: Exclude<ServiceProps["cpu"], undefined>;
     path: Exclude<ServiceProps["path"], undefined>;
     memory: Exclude<ServiceProps["memory"], undefined>;
+    storage: Exclude<ServiceProps["storage"], undefined>;
     port: Exclude<ServiceProps["port"], undefined>;
     logRetention: Exclude<ServiceProps["logRetention"], undefined>;
 };
@@ -468,7 +480,7 @@ export declare class Service extends Construct implements SSTConstruct {
      */
     addEnvironment(name: string, value: string): void;
     private validateServiceExists;
-    private validateMemoryAndCpu;
+    private validateMemoryCpuAndStorage;
     private createVpc;
     private createService;
     private createLoadBalancer;

package/constructs/Service.js

@@ -18,12 +18,13 @@ import { useDeferredTasks } from "./deferred_task.js";
 import { attachPermissionsToRole } from "./util/permission.js";
 import { bindEnvironment, bindPermissions, getParameterPath, getReferencedSecrets, } from "./util/functionBinding.js";
 import { useProject } from "../project.js";
-import { Vpc, } from "aws-cdk-lib/aws-ec2";
+import { Vpc } from "aws-cdk-lib/aws-ec2";
 import { AwsLogDriver, Cluster, ContainerImage, CpuArchitecture, FargateService, FargateTaskDefinition, } from "aws-cdk-lib/aws-ecs";
 import { LogGroup, LogRetention, RetentionDays } from "aws-cdk-lib/aws-logs";
 import { Platform } from "aws-cdk-lib/aws-ecr-assets";
 import { ApplicationLoadBalancer, } from "aws-cdk-lib/aws-elasticloadbalancingv2";
 import { createAppContext } from "./context.js";
+import { toCdkSize } from "./index.js";
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 const NIXPACKS_IMAGE_NAME = "sst-nixpacks";
 const supportedCpus = {
@@ -158,6 +159,7 @@ export class Service extends Construct {
             architecture: props?.architecture || "x86_64",
             cpu: props?.cpu || "0.25 vCPU",
             memory: props?.memory || "0.5 GB",
+            storage: props?.storage || "20 GB",
             port: props?.port || 3000,
             logRetention: props?.logRetention || "infinite",
             ...props,
@@ -165,7 +167,7 @@ export class Service extends Construct {
         this.doNotDeploy =
             !stack.isActive || (app.mode === "dev" && !this.props.dev?.deploy);
         this.validateServiceExists();
-        this.validateMemoryAndCpu();
+        this.validateMemoryCpuAndStorage();
         useServices().add(stack.stackName, id, this.props);
         if (this.doNotDeploy) {
             this.devFunction = this.createDevFunction();
@@ -376,8 +378,8 @@ export class Service extends Construct {
             }
         }
     }
-    validateMemoryAndCpu() {
-        const { memory, cpu } = this.props;
+    validateMemoryCpuAndStorage() {
+        const { memory, cpu, storage } = this.props;
         if (!supportedCpus[cpu]) {
             throw new VisibleError(`In the "${this.node.id}" Service, only the following "cpu" settings are supported: ${Object.keys(supportedCpus).join(", ")}`);
         }
@@ -385,6 +387,10 @@ export class Service extends Construct {
         if (!supportedMemories[cpu][memory]) {
             throw new VisibleError(`In the "${this.node.id}" Service, only the following "memory" settings are supported with "${cpu}": ${Object.keys(supportedMemories[cpu]).join(", ")}`);
         }
+        const storageInGiB = toCdkSize(storage).toGibibytes();
+        if (storageInGiB < 20 || storageInGiB > 200) {
+            throw new VisibleError(`In the "${this.node.id}" Service, the supported value for storage is between "20 GB" and "200 GB"`);
+        }
     }
     createVpc() {
         const { cdk } = this.props;
@@ -394,7 +400,7 @@ export class Service extends Construct {
             }));
     }
     createService(vpc) {
-        const { architecture, cpu, memory, port, logRetention, cdk } = this.props;
+        const { architecture, cpu, memory, storage, port, logRetention, cdk } = this.props;
         const app = this.node.root;
         const clusterName = app.logicalPrefixedName(this.node.id);
         const logGroup = new LogRetention(this, "LogRetention", {
@@ -408,10 +414,14 @@ export class Service extends Construct {
             clusterName,
             vpc,
         });
+        const ephemeralStorageGiB = toCdkSize(storage).toGibibytes();
         const taskDefinition = new FargateTaskDefinition(this, `TaskDefinition`, {
-            // @ts-ignore
+            // @ts-expect-error
             memoryLimitMiB: supportedMemories[cpu][memory],
             cpu: supportedCpus[cpu],
+            // note: the minimum allowed value by CloudFormation is 21, set to
+            //       undefined to set to the default value of 20
+            ephemeralStorageGiB: ephemeralStorageGiB === 20 ? undefined : ephemeralStorageGiB,
             runtimePlatform: {
                 cpuArchitecture: architecture === "arm64"
                     ? CpuArchitecture.ARM64

package/constructs/SsrFunction.js

@@ -40,6 +40,7 @@ export class SsrFunction extends Construct {
             memorySize: 1024,
             streaming: false,
             injections: [],
+            architecture: Architecture.ARM_64,
             ...props,
             environment: props.environment || {},
             permissions: props.permissions || [],
@@ -104,7 +105,7 @@ export class SsrFunction extends Construct {
                 : runtime === "nodejs16.x"
                     ? Runtime.NODEJS_16_X
                     : Runtime.NODEJS_18_X,
-            architecture: architecture || Architecture.ARM_64,
+            architecture,
             memorySize: typeof memorySize === "string"
                 ? toCdkSize(memorySize).toMebibytes()
                 : memorySize,
@@ -173,11 +174,13 @@ export class SsrFunction extends Construct {
         });
     }
     async buildAssetFromHandler() {
-        const { handler, runtime, nodejs, copyFiles, injections } = this.props;
+        const { handler, runtime, nodejs, copyFiles, architecture: enumArchitecture, } = this.props;
+        const architecture = enumArchitecture === Architecture.X86_64 ? "x86_64" : "arm_64";
         useFunctions().add(this.node.addr, {
             handler,
             runtime,
             nodejs,
+            architecture,
             copyFiles,
         });
         // build function

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/node/future/auth/index.d.ts

@@ -10,6 +10,7 @@ export * from "./adapter/microsoft.js";
 export * from "./adapter/oauth.js";
 export * from "./adapter/spotify.js";
 export * from "./adapter/code.js";
+export * from "./adapter/apple.js";
 export type { Adapter } from "./adapter/adapter.js";
 export * from "./session.js";
 export * from "./handler.js";

package/node/future/auth/index.js

@@ -9,6 +9,7 @@ export * from "./adapter/microsoft.js";
 export * from "./adapter/oauth.js";
 export * from "./adapter/spotify.js";
 export * from "./adapter/code.js";
+export * from "./adapter/apple.js";
 export * from "./session.js";
 export * from "./handler.js";
 export * from "./encryption.js";

package/node/graphql/index.d.ts

@@ -9,7 +9,7 @@ export declare function GraphQLHandler<UserContext extends {}>(options: YogaServ
     headers: {
         [k: string]: string;
     };
-    body: any;
+    body: string;
     isBase64Encoded: boolean;
 }>;
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "sideEffects": false,
   "name": "sst",
-  "version": "2.36.8",
+  "version": "2.37.1",
   "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.8",
+    "astro-sst": "2.37.1",
     "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;
-}