sst 2.8.23 → 2.8.25

package/constructs/Api.js

@@ -586,6 +586,7 @@ export class Api extends Construct {
         }, postfixName);
         const data = this.routesData[routeKey];
         if (data.type === "function") {
+            data.function.addEnvironment("GRAPHQL_ENDPOINT", routeKey.split(" ")[1]);
             this.routesData[routeKey] = {
                 ...data,
                 type: "graphql",

package/constructs/Job.js

@@ -249,13 +249,13 @@ export class Job extends Construct {
         //       in the Console.
         const fn = new Function(this, this.node.id, {
             runtime: "nodejs16.x",
-            timeout: "15 minutes",
             memorySize: 1024,
             environment: {
                 ...this.props.environment,
                 SST_DEBUG_TYPE: "job",
             },
             ...this.props,
+            timeout: "15 minutes",
         });
         fn._doNotAllowOthersToBind = true;
         return fn;

package/constructs/NextjsSite.d.ts

@@ -16,6 +16,11 @@ export interface NextjsSiteProps extends Omit<SsrSiteProps, "nodejs"> {
          */
         memorySize?: number | Size;
     };
+    /**
+     * The number of server functions to keep warm. This option is only supported for the regional mode.
+     * @default Server function is not kept warm
+     */
+    warm?: number;
 }
 /**
  * The `NextjsSite` construct is a higher level CDK construct that makes it easy to create a Next.js app.
@@ -46,6 +51,7 @@ export declare class NextjsSite extends SsrSite {
     protected createFunctionForRegional(): CdkFunction;
     protected createFunctionForEdge(): EdgeFunction;
     private createImageOptimizationFunction;
+    private createWarmer;
     protected createCloudFrontDistributionForRegional(): Distribution;
     protected createCloudFrontDistributionForEdge(): Distribution;
     private buildServerBehaviorForRegional;

package/constructs/NextjsSite.js

@@ -1,16 +1,19 @@
 import fs from "fs";
 import url from "url";
 import path from "path";
-import { Fn, Duration as CdkDuration, RemovalPolicy } from "aws-cdk-lib";
+import { Fn, Duration as CdkDuration, RemovalPolicy, CustomResource, } from "aws-cdk-lib";
+import { Effect, Policy, PolicyStatement } from "aws-cdk-lib/aws-iam";
 import { RetentionDays } from "aws-cdk-lib/aws-logs";
 import { Function as CdkFunction, Code, Runtime, Architecture, FunctionUrlAuthType, } from "aws-cdk-lib/aws-lambda";
 import { Distribution, ViewerProtocolPolicy, AllowedMethods, LambdaEdgeEventType, CachedMethods, CachePolicy, } from "aws-cdk-lib/aws-cloudfront";
 import { S3Origin, HttpOrigin, OriginGroup, } from "aws-cdk-lib/aws-cloudfront-origins";
+import { Rule, Schedule } from "aws-cdk-lib/aws-events";
+import { LambdaFunction } from "aws-cdk-lib/aws-events-targets";
+import { Stack } from "./Stack.js";
 import { SsrFunction } from "./SsrFunction.js";
 import { EdgeFunction } from "./EdgeFunction.js";
 import { SsrSite } from "./SsrSite.js";
 import { toCdkSize } from "./util/size.js";
-import { PolicyStatement } from "aws-cdk-lib/aws-iam";
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 /**
  * The `NextjsSite` construct is a higher level CDK construct that makes it easy to create a Next.js app.
@@ -26,9 +29,10 @@ 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@~1.2.0 build",
+            buildCommand: "npx --yes open-next@~1.3.0 build",
             ...props,
         });
+        this.createWarmer();
     }
     initBuildConfig() {
         return {
@@ -41,7 +45,7 @@ export class NextjsSite extends SsrSite {
     createFunctionForRegional() {
         const { runtime, timeout, memorySize, bind, permissions, environment, cdk, } = this.props;
         const ssrFn = new SsrFunction(this, `ServerFunction`, {
-            description: "Server handler for Next.js",
+            description: "Next.js server",
             bundle: path.join(this.props.path, ".open-next", "server-function"),
             handler: "index.handler",
             runtime,
@@ -70,7 +74,7 @@ export class NextjsSite extends SsrSite {
     createImageOptimizationFunction() {
         const { imageOptimization, path: sitePath } = this.props;
         return new CdkFunction(this, `ImageFunction`, {
-            description: "Image optimization handler for Next.js",
+            description: "Next.js image optimizer",
             handler: "index.handler",
             currentVersionOptions: {
                 removalPolicy: RemovalPolicy.DESTROY,
@@ -96,6 +100,56 @@ export class NextjsSite extends SsrSite {
             ],
         });
     }
+    createWarmer() {
+        const { warm, edge } = this.props;
+        if (!warm)
+            return;
+        if (warm && edge) {
+            throw new Error(`Warming is currently supported only for the regional mode.`);
+        }
+        if (!this.serverLambdaForRegional)
+            return;
+        // Create warmer function
+        const warmer = new CdkFunction(this, "WarmerFunction", {
+            description: "Next.js warmer",
+            code: Code.fromAsset(path.join(this.props.path, ".open-next/warmer-function")),
+            runtime: Runtime.NODEJS_18_X,
+            handler: "index.handler",
+            timeout: CdkDuration.minutes(15),
+            memorySize: 1024,
+            environment: {
+                FUNCTION_NAME: this.serverLambdaForRegional.functionName,
+                CONCURRENCY: warm.toString(),
+            },
+        });
+        this.serverLambdaForRegional.grantInvoke(warmer);
+        // Create cron job
+        new Rule(this, "WarmerRule", {
+            schedule: Schedule.rate(CdkDuration.minutes(5)),
+            targets: [new LambdaFunction(warmer, { retryAttempts: 0 })],
+        });
+        // Create custom resource to prewarm on deploy
+        const stack = Stack.of(this);
+        const policy = new Policy(this, "PrewarmerPolicy", {
+            statements: [
+                new PolicyStatement({
+                    effect: Effect.ALLOW,
+                    actions: ["lambda:InvokeFunction"],
+                    resources: [warmer.functionArn],
+                }),
+            ],
+        });
+        stack.customResourceHandler.role?.attachInlinePolicy(policy);
+        const resource = new CustomResource(this, "Prewarmer", {
+            serviceToken: stack.customResourceHandler.functionArn,
+            resourceType: "Custom::FunctionInvoker",
+            properties: {
+                version: Date.now().toString(),
+                functionName: warmer.functionName,
+            },
+        });
+        resource.node.addDependency(policy);
+    }
     createCloudFrontDistributionForRegional() {
         /**
          * Next.js requests

package/constructs/WebSocketApi.d.ts

@@ -15,7 +15,7 @@ export interface WebSocketApiAccessLogProps extends apigV2AccessLog.AccessLogPro
 }
 export interface WebSocketApiProps {
     /**
-     * The routes for the Websocket API
+     * The routes for the WebSocket API
      *
      * @example
      * ```js

package/constructs/WebSocketApi.js

@@ -195,12 +195,16 @@ export class WebSocketApi extends Construct {
     /** @internal */
     getFunctionBinding() {
         return {
-            clientPackage: "api",
+            clientPackage: "websocket-api",
             variables: {
                 url: {
                     type: "plain",
                     value: this.customDomainUrl || this.url,
                 },
+                httpsUrl: {
+                    type: "plain",
+                    value: (this.customDomainUrl || this.url).replace("wss://", "https://"),
+                },
             },
             permissions: {
                 "execute-api:ManageConnections": [this._connectionsArn],

package/context/handler.d.ts

@@ -1,16 +1,25 @@
-import { APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2, Context as LambdaContext, SQSBatchResponse, SQSEvent } from "aws-lambda";
+import { APIGatewayProxyEventHeaders, APIGatewayProxyEventMultiValueHeaders, APIGatewayProxyEventMultiValueQueryStringParameters, APIGatewayProxyEventQueryStringParameters, APIGatewayProxyEventV2, APIGatewayProxyResultV2, APIGatewayProxyStructuredResultV2, APIGatewayProxyWebsocketEventV2, Context as LambdaContext, SQSBatchResponse, SQSEvent } from "aws-lambda";
 export interface Handlers {
     api: {
         event: APIGatewayProxyEventV2;
         response: APIGatewayProxyStructuredResultV2 | void;
     };
+    ws: {
+        event: APIGatewayProxyWebsocketEventV2 & {
+            headers?: APIGatewayProxyEventHeaders;
+            multiValueHeaders?: APIGatewayProxyEventMultiValueHeaders;
+            queryStringParameters?: APIGatewayProxyEventQueryStringParameters | null;
+            multiValueQueryStringParameters?: APIGatewayProxyEventMultiValueQueryStringParameters | null;
+        };
+        response: APIGatewayProxyResultV2;
+    };
     sqs: {
         event: SQSEvent;
         response: SQSBatchResponse;
     };
 }
-type HandlerTypes = keyof Handlers;
+export type HandlerTypes = keyof Handlers;
+export declare function useContextType(): HandlerTypes;
 export declare function useEvent<Type extends HandlerTypes>(type: Type): Handlers[Type]["event"];
 export declare function useLambdaContext(): LambdaContext;
 export declare function Handler<Type extends HandlerTypes, Event = Handlers[Type]["event"], Response = Handlers[Type]["response"]>(type: Type, cb: (evt: Event, ctx: LambdaContext) => Promise<Response>): (event: Event, context: LambdaContext) => Promise<Response>;
-export {};

package/context/handler.js

@@ -1,5 +1,9 @@
 import { Context } from "./context.js";
 const RequestContext = Context.create("RequestContext");
+export function useContextType() {
+    const ctx = RequestContext.use();
+    return ctx.type;
+}
 export function useEvent(type) {
     const ctx = RequestContext.use();
     if (ctx.type !== type)

package/node/api/index.d.ts

@@ -1,4 +1,4 @@
-import { Handler } from "../../context/handler.js";
+import { Handler, HandlerTypes } from "../../context/handler.js";
 import { APIGatewayProxyStructuredResultV2 } from "aws-lambda";
 export interface ApiResources {
 }
@@ -6,12 +6,10 @@ export interface AppSyncApiResources {
 }
 export interface ApiGatewayV1ApiResources {
 }
-export interface WebSocketApiResources {
-}
+export type ApiHandlerTypes = Extract<HandlerTypes, "api" | "ws">;
 export declare const Api: ApiResources;
 export declare const AppSyncApi: AppSyncApiResources;
 export declare const ApiGatewayV1Api: ApiGatewayV1ApiResources;
-export declare const WebSocketApi: WebSocketApiResources;
 /**
  * Create a new api handler that can be used to create an authenticated session.
  *

package/node/api/index.js

@@ -1,13 +1,11 @@
 import { createProxy } from "../util/index.js";
 import { Context } from "../../context/context.js";
-import { useEvent, Handler } from "../../context/handler.js";
+import { useEvent, Handler, useContextType, } from "../../context/handler.js";
 export const Api = /* @__PURE__ */ createProxy("Api");
 export const AppSyncApi = 
 /* @__PURE__ */ createProxy("AppSyncApi");
 export const ApiGatewayV1Api = 
 /* @__PURE__ */ createProxy("ApiGatewayV1Api");
-export const WebSocketApi = 
-/* @__PURE__ */ createProxy("WebSocketApi");
 /**
  * Create a new api handler that can be used to create an authenticated session.
  *
@@ -34,7 +32,8 @@ export function useCookie(name) {
     return cookies[name];
 }
 export const useBody = /* @__PURE__ */ Context.memo(() => {
-    const evt = useEvent("api");
+    const type = useContextType();
+    const evt = useEvent(type);
     if (!evt.body)
         return;
     const body = evt.isBase64Encoded
@@ -118,7 +117,8 @@ export const useResponse = /* @__PURE__ */ Context.memo(() => {
     return result;
 });
 export function useDomainName() {
-    const evt = useEvent("api");
+    const type = useContextType();
+    const evt = useEvent(type);
     return evt.requestContext.domainName;
 }
 export function useMethod() {
@@ -126,7 +126,8 @@ export function useMethod() {
     return evt.requestContext.http.method;
 }
 export function useHeaders() {
-    const evt = useEvent("api");
+    const type = useContextType();
+    const evt = useEvent(type);
     return evt.headers || {};
 }
 export function useHeader(key) {
@@ -138,7 +139,8 @@ export function useFormValue(name) {
     return params?.get(name);
 }
 export function useQueryParams() {
-    const evt = useEvent("api");
+    const type = useContextType();
+    const evt = useEvent(type);
     const query = evt.queryStringParameters || {};
     return query;
 }

package/node/auth/session.js

@@ -2,14 +2,26 @@ import { createSigner, createVerifier } from "fast-jwt";
 import { Context } from "../../context/context.js";
 import { useCookie, useHeader } from "../api/index.js";
 import { getPrivateKey, getPublicKey } from "./auth.js";
+import { useContextType } from "../../context/handler.js";
 const SessionMemo = /* @__PURE__ */ Context.memo(() => {
+    // Get the context type and hooks that match that type
     let token = "";
     const header = useHeader("authorization");
     if (header)
         token = header.substring(7);
-    const cookie = useCookie("auth-token");
+    const ctxType = useContextType();
+    const cookie = ctxType === "api" ? useCookie("auth-token") : undefined;
     if (cookie)
         token = cookie;
+    // WebSocket may also set the token in the protocol header
+    // TODO: Once https://github.com/serverless-stack/sst/pull/2838 is merged,
+    // then we should no longer need to check both casing for the header.
+    const wsProtocol = ctxType === "ws"
+        ? useHeader("sec-websocket-protocol") ||
+            useHeader("Sec-WebSocket-Protocol")
+        : undefined;
+    if (wsProtocol)
+        token = wsProtocol.split(",")[0].trim();
     if (token) {
         const jwt = createVerifier({
             algorithms: ["RS512"],

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

@@ -0,0 +1,20 @@
+import { OidcBasicConfig } from "./oidc.js";
+type MicrosoftConfig = OidcBasicConfig & {
+    mode: "oidc";
+};
+export declare function MicrosoftAdapter(config: MicrosoftConfig): () => Promise<{
+    type: "success";
+    properties: {
+        tokenset: import("openid-client").TokenSet;
+        client: import("openid-client").BaseClient;
+    };
+} | {
+    type: "step";
+    properties: {
+        statusCode: number;
+        headers: {
+            location: string;
+        };
+    };
+}>;
+export {};

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

@@ -0,0 +1,14 @@
+import { Issuer } from "openid-client";
+import { OidcAdapter } from "./oidc.js";
+// These are the different Microsoft auth urls for different types of accounts:
+// Common: https://login.microsoftonline.com/common/v2.0 (both business and private)
+// Business: https://login.microsoftonline.com/{tenant}/v2.0
+// Private: https://login.microsoftonline.com/consumers/v2.0
+const issuer = await Issuer.discover("https://login.microsoftonline.com/common/v2.0");
+export function MicrosoftAdapter(config) {
+    return OidcAdapter({
+        issuer,
+        scope: "openid email profile",
+        ...config,
+    });
+}

package/node/future/auth/index.d.ts

@@ -6,6 +6,7 @@ export * from "./adapter/google.js";
 export * from "./adapter/link.js";
 export * from "./adapter/github.js";
 export * from "./adapter/facebook.js";
+export * from "./adapter/microsoft.js";
 export * from "./adapter/oauth.js";
 export type { Adapter } from "./adapter/adapter.js";
 export * from "./session.js";

package/node/future/auth/index.js

@@ -5,6 +5,7 @@ export * from "./adapter/google.js";
 export * from "./adapter/link.js";
 export * from "./adapter/github.js";
 export * from "./adapter/facebook.js";
+export * from "./adapter/microsoft.js";
 export * from "./adapter/oauth.js";
 export * from "./session.js";
 export * from "./handler.js";

package/node/future/auth/session.js

@@ -3,14 +3,26 @@ import { Context } from "../../../context/context.js";
 import { useCookie, useHeader } from "../../api/index.js";
 import { Auth } from "../../auth/index.js";
 import { Config } from "../../config/index.js";
+import { useContextType } from "../../../context/handler.js";
 const SessionMemo = /* @__PURE__ */ Context.memo(() => {
+    // Get the context type and hooks that match that type
     let token = "";
     const header = useHeader("authorization");
     if (header)
         token = header.substring(7);
-    const cookie = useCookie("sst_auth_token");
+    const ctxType = useContextType();
+    const cookie = ctxType === "api" ? useCookie("sst_auth_token") : undefined;
     if (cookie)
         token = cookie;
+    // WebSocket may also set the token in the protocol header
+    // TODO: Once https://github.com/serverless-stack/sst/pull/2838 is merged,
+    // then we should no longer need to check both casing for the header.
+    const wsProtocol = ctxType === "ws"
+        ? useHeader("sec-websocket-protocol") ||
+            useHeader("Sec-WebSocket-Protocol")
+        : undefined;
+    if (wsProtocol)
+        token = wsProtocol.split(",")[0].trim();
     if (token) {
         return Session.verify(token);
     }

package/node/graphql/index.js

@@ -1,7 +1,10 @@
 import { createYoga } from "graphql-yoga";
 import { Handler, useEvent, useLambdaContext } from "../../context/handler.js";
 export function GraphQLHandler(options) {
-    const yoga = createYoga(options);
+    const yoga = createYoga({
+        graphqlEndpoint: process.env.GRAPHQL_ENDPOINT,
+        ...options,
+    });
     return Handler("api", async () => {
         const event = useEvent("api");
         const parameters = new URLSearchParams(event.queryStringParameters || {}).toString();

package/node/websocket-api/index.d.ts

@@ -0,0 +1,23 @@
+import { Handler } from "../../context/handler.js";
+export interface WebSocketApiResources {
+}
+export declare const WebSocketApi: WebSocketApiResources;
+/**
+ * Create a new WebSocketApi handler that can be used to create an
+ * authenticated session.
+ *
+ * @example
+ * ```ts
+ * export const handler = WebSocketApiHandler({
+ * })
+ * ```
+ */
+export declare function WebSocketApiHandler(cb: Parameters<typeof Handler<"ws">>[1]): (event: import("aws-lambda").APIGatewayProxyWebsocketEventV2 & {
+    headers?: import("aws-lambda").APIGatewayProxyEventHeaders | undefined;
+    multiValueHeaders?: import("aws-lambda").APIGatewayProxyEventMultiValueHeaders | undefined;
+    queryStringParameters?: import("aws-lambda").APIGatewayProxyEventQueryStringParameters | null | undefined;
+    multiValueQueryStringParameters?: import("aws-lambda").APIGatewayProxyEventMultiValueQueryStringParameters | null | undefined;
+}, context: import("aws-lambda").Context) => Promise<any>;
+export declare function useRequestContext(): import("aws-lambda").APIGatewayEventWebsocketRequestContextV2;
+export declare function useConnectionId(): string;
+export declare function useEventType(): "CONNECT" | "MESSAGE" | "DISCONNECT";

package/node/websocket-api/index.js

@@ -0,0 +1,48 @@
+import { Handler, useEvent } from "../../context/handler.js";
+import { useHeader } from "../api/index.js";
+import { createProxy } from "../util/index.js";
+export const WebSocketApi = 
+/* @__PURE__ */ createProxy("WebSocketApi");
+/**
+ * Create a new WebSocketApi handler that can be used to create an
+ * authenticated session.
+ *
+ * @example
+ * ```ts
+ * export const handler = WebSocketApiHandler({
+ * })
+ * ```
+ */
+export function WebSocketApiHandler(cb) {
+    return Handler("ws", async (evt, ctx) => {
+        const result = await cb(evt, ctx);
+        // TODO: Once https://github.com/serverless-stack/sst/pull/2838 is merged,
+        // then we should no longer need to check both casing for the header.
+        const token = useHeader("Sec-WebSocket-Protocol") ||
+            useHeader("sec-websocket-protocol");
+        // If a token was set as part of the sec-websocket-protocol, we need to
+        // return it as a header in the response.
+        // https://docs.aws.amazon.com/apigateway/latest/developerguide/websocket-connect-route-subprotocol.html
+        if (token) {
+            return {
+                ...(result || {}),
+                headers: {
+                    "Sec-WebSocket-Protocol": token,
+                },
+            };
+        }
+        return result;
+    });
+}
+export function useRequestContext() {
+    const evt = useEvent("ws");
+    return evt.requestContext;
+}
+export function useConnectionId() {
+    const requestContext = useRequestContext();
+    return requestContext.connectionId;
+}
+export function useEventType() {
+    const requestContext = useRequestContext();
+    return requestContext.eventType;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "sideEffects": false,
   "name": "sst",
-  "version": "2.8.23",
+  "version": "2.8.25",
   "bin": {
     "sst": "cli/sst.js"
   },
@@ -48,6 +48,7 @@
     "@babel/core": "^7.0.0-0",
     "@babel/generator": "^7.20.5",
     "@trpc/server": "9.16.0",
+    "adm-zip": "^0.5.10",
     "aws-cdk-lib": "2.72.1",
     "aws-iot-device-sdk": "^2.2.12",
     "aws-sdk": "^2.1326.0",
@@ -85,8 +86,7 @@
     "undici": "^5.12.0",
     "uuid": "^9.0.0",
     "ws": "^8.11.0",
-    "yargs": "^17.6.2",
-    "zip-local": "^0.3.5"
+    "yargs": "^17.6.2"
   },
   "devDependencies": {
     "@aws-sdk/client-api-gateway": "^3.208.0",
@@ -110,7 +110,6 @@
     "@types/uuid": "^8.3.4",
     "@types/ws": "^8.5.3",
     "@types/yargs": "^17.0.13",
-    "adm-zip": "^0.5.10",
     "archiver": "^5.3.1",
     "tsx": "^3.12.1",
     "typescript": "^4.9.5",

package/runtime/handlers/java.js

@@ -4,13 +4,13 @@ import os from "os";
 import { useRuntimeHandlers } from "../handlers.js";
 import { useRuntimeWorkers } from "../workers.js";
 import { Context } from "../../context/context.js";
-import zipLocal from "zip-local";
 import { spawn } from "child_process";
 import { useRuntimeServerConfig } from "../server.js";
 import { existsAsync, findBelow, isChild } from "../../util/fs.js";
 import { useProject } from "../../project.js";
 import { execAsync } from "../../util/process.js";
 import url from "url";
+import AdmZip from "adm-zip";
 export const useJavaHandler = Context.memo(async () => {
     const workers = await useRuntimeWorkers();
     const server = await useRuntimeServerConfig();
@@ -74,7 +74,7 @@ export const useJavaHandler = Context.memo(async () => {
                 });
                 const buildOutput = path.join(srcPath, "build", outputDir);
                 const zip = (await fs.readdir(buildOutput)).find((f) => f.endsWith(".zip"));
-                zipLocal.sync.unzip(path.join(buildOutput, zip)).save(input.out);
+                new AdmZip(path.join(buildOutput, zip)).extractAllTo(input.out);
                 return {
                     type: "success",
                     handler: input.props.handler,

package/sst.mjs

@@ -4848,9 +4848,9 @@ __export(java_exports, {
 import path13 from "path";
 import fs12 from "fs/promises";
 import os5 from "os";
-import zipLocal from "zip-local";
 import { spawn as spawn5 } from "child_process";
 import url7 from "url";
+import AdmZip from "adm-zip";
 async function getGradleBinary(srcPath) {
   const gradleWrapperPath = path13.resolve(path13.join(srcPath, "gradlew"));
   return await existsAsync(gradleWrapperPath) ? gradleWrapperPath : "gradle";
@@ -4940,7 +4940,7 @@ var init_java = __esm({
             const zip = (await fs12.readdir(buildOutput)).find(
               (f) => f.endsWith(".zip")
             );
-            zipLocal.sync.unzip(path13.join(buildOutput, zip)).save(input.out);
+            new AdmZip(path13.join(buildOutput, zip)).extractAllTo(input.out);
             return {
               type: "success",
               handler: input.props.handler