sst 2.24.20 → 2.24.21

package/constructs/EventBus.d.ts

@@ -426,7 +426,6 @@ export declare class EventBus extends Construct implements SSTConstruct {
     getFunctionBinding(): FunctionBindingProps;
     private retrierQueue;
     private retrierFn;
-    private retrierMap;
     private getRetrier;
     private createEventBus;
     private addRule;
@@ -437,6 +436,9 @@ export declare class EventBus extends Construct implements SSTConstruct {
     private subs;
     subscribe(type: string | string[], target: FunctionDefinition, props?: {
         retries?: number;
-    }): this;
+    }): EventBus;
+    subscribe(scope: Construct, type: string | string[], target: FunctionDefinition, props?: {
+        retries?: number;
+    }): EventBus;
     private addFunctionTarget;
 }

package/constructs/EventBus.js

@@ -10,6 +10,9 @@ import { SqsEventSource } from "aws-cdk-lib/aws-lambda-event-sources";
 import { SqsDestination } from "aws-cdk-lib/aws-lambda-destinations";
 import url from "url";
 import path from "path";
+import { Effect, PolicyStatement } from "aws-cdk-lib/aws-iam";
+import { Duration } from "aws-cdk-lib/core";
+import { Stack } from "./Stack.js";
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
 /////////////////////
 // Construct
@@ -233,7 +236,6 @@ export class EventBus extends Construct {
     }
     retrierQueue;
     retrierFn;
-    retrierMap = {};
     getRetrier() {
         const app = this.node.root;
         if (this.retrierFn && this.retrierQueue) {
@@ -245,12 +247,26 @@ export class EventBus extends Construct {
         this.retrierFn = new lambda.Function(this, `RetrierFunction`, {
             functionName: app.logicalPrefixedName(this.node.id + "Retrier"),
             runtime: lambda.Runtime.NODEJS_14_X,
+            timeout: Duration.seconds(30),
             handler: "index.handler",
             code: lambda.Code.fromAsset(path.join(__dirname, "../support/event-bus-retrier")),
             environment: {
                 RETRIER_QUEUE_URL: this.retrierQueue.queueUrl,
             },
         });
+        this.retrierFn.addToRolePolicy(new PolicyStatement({
+            effect: Effect.ALLOW,
+            actions: ["lambda:InvokeFunction", "lambda:GetFunction"],
+            resources: [
+                `arn:${Stack.of(this).partition}:lambda:${app.region}:${app.account}:function:*`,
+            ],
+            conditions: {
+                StringEquals: {
+                    "aws:ResourceTag/sst:app": app.name,
+                    "aws:ResourceTag/sst:stage": app.stage,
+                },
+            },
+        }));
         this.retrierFn.addEventSource(new SqsEventSource(this.retrierQueue));
         this.retrierQueue.grantSendMessages(this.retrierFn);
         return { fn: this.retrierFn, queue: this.retrierQueue };
@@ -353,7 +369,18 @@ export class EventBus extends Construct {
         eventsRule.addTarget(new LambdaFunctionTarget(fn, targetProps));
     }
     subs = new Map();
-    subscribe(type, target, props) {
+    subscribe(scope_or_type, type_or_target, target_or_props, maybe_props) {
+        let [scope, type, target, props] = (() => {
+            if (scope_or_type instanceof Construct) {
+                return [
+                    scope_or_type,
+                    type_or_target,
+                    target_or_props,
+                    maybe_props,
+                ];
+            }
+            return [this, scope_or_type, type_or_target, maybe_props];
+        })();
         type = Array.isArray(type) ? type : [type];
         const joined = type.length > 1 ? "multi" : type.join("_");
         const count = (this.subs.get(joined) || 0) + 1;
@@ -363,17 +390,15 @@ export class EventBus extends Construct {
         const fn = (() => {
             if (retries) {
                 const retrier = this.getRetrier();
-                const fn = Fn.fromDefinition(this, name, target, {
+                const fn = Fn.fromDefinition(scope, name, target, {
                     onFailure: new SqsDestination(retrier.queue),
                 });
-                this.retrierMap[fn.functionArn] = retries;
-                retrier.fn.addEnvironment(`RETRIES`, JSON.stringify(this.retrierMap));
-                fn.grantInvoke(retrier.fn);
+                fn.addEnvironment("SST_RETRIES", retries.toString());
                 return fn;
             }
-            return Fn.fromDefinition(this, name, target);
+            return Fn.fromDefinition(scope, name, target);
         })();
-        this.addRule(this, name + "_rule", {
+        this.addRule(scope, name + "_rule", {
             pattern: {
                 detailType: type,
             },

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

@@ -12,6 +12,10 @@ interface OnSuccessResponder<T> {
         properties: typeof input;
     };
 }
+export declare class UnknownProviderError {
+    provider?: string | undefined;
+    constructor(provider?: string | undefined);
+}
 export declare function AuthHandler<Providers extends Record<string, Adapter<any>>, Sessions extends SessionBuilder, Result = {
     [key in keyof Providers]: {
         provider: key;
@@ -25,6 +29,6 @@ export declare function AuthHandler<Providers extends Record<string, Adapter<any
     onAuthorize?: (event: APIGatewayProxyEventV2) => Promise<void | keyof Providers>;
     onSuccess: (input: Result, response: OnSuccessResponder<SessionValue | Sessions["$type"]>) => Promise<ReturnType<OnSuccessResponder<SessionValue | Sessions["$type"]>[keyof OnSuccessResponder<any>]>>;
     onIndex?: (event: APIGatewayProxyEventV2) => Promise<APIGatewayProxyStructuredResultV2>;
-    onError?: () => Promise<APIGatewayProxyStructuredResultV2>;
+    onError?: (error: UnknownProviderError) => Promise<APIGatewayProxyStructuredResultV2 | undefined>;
 }): (event: APIGatewayProxyEventV2, context: import("aws-lambda").Context) => Promise<APIGatewayProxyStructuredResultV2>;
 export {};

package/node/future/auth/handler.js

@@ -1,6 +1,12 @@
 import { createSigner, createVerifier } from "fast-jwt";
 import { ApiHandler, useCookie, useCookies, useFormValue, usePathParam, useQueryParam, useQueryParams, useResponse, } from "../../api/index.js";
 import { Config } from "../../config/index.js";
+export class UnknownProviderError {
+    provider;
+    constructor(provider) {
+        this.provider = provider;
+    }
+}
 export function AuthHandler(input) {
     return ApiHandler(async (evt) => {
         const step = usePathParam("step");
@@ -139,6 +145,9 @@ export function AuthHandler(input) {
             });
         }
         if (!provider || !input.providers[provider]) {
+            const response = input.onError?.(new UnknownProviderError(provider));
+            if (response)
+                return response;
             return {
                 statusCode: 400,
                 body: `Was not able to find provider "${String(provider)}"`,
@@ -246,8 +255,6 @@ export function AuthHandler(input) {
             }
         }
         if (result.type === "error") {
-            if (input.onError)
-                return input.onError();
             return {
                 statusCode: 400,
                 body: "an error has occured",

package/package.json

@@ -1,7 +1,7 @@
 {
   "sideEffects": false,
   "name": "sst",
-  "version": "2.24.20",
+  "version": "2.24.21",
   "bin": {
     "sst": "cli/sst.js"
   },