sst 2.24.19 → 2.24.21

package/cli/sst.js

@@ -55,6 +55,7 @@ process.on("uncaughtException", (err) => {
             spinner.fail(spinner.text);
     }
     if (!(err instanceof SilentError)) {
+        console.log();
         console.log(red("Error:"), err.message);
         if (!(err instanceof VisibleError)) {
             console.log();

package/config.js

@@ -5,7 +5,6 @@ import { useProject } from "./project.js";
 import { useAWSClient } from "./credentials.js";
 import { useIOT } from "./iot.js";
 import { Stacks } from "./stacks/index.js";
-const ssm = useAWSClient(SSMClient);
 const FALLBACK_STAGE = ".fallback";
 const SECRET_UPDATED_AT_ENV = "SST_ADMIN_SECRET_UPDATED_AT";
 const PREFIX = {
@@ -171,6 +170,7 @@ export var Config;
     Config.restart = restart;
 })(Config || (Config = {}));
 async function* scanParameters(prefix) {
+    const ssm = useAWSClient(SSMClient);
     let token;
     while (true) {
         const results = await ssm.send(new GetParametersByPathCommand({
@@ -186,12 +186,14 @@ async function* scanParameters(prefix) {
     }
 }
 function getParameter(name) {
+    const ssm = useAWSClient(SSMClient);
     return ssm.send(new GetParameterCommand({
         Name: name,
         WithDecryption: true,
     }));
 }
 function putParameter(name, value) {
+    const ssm = useAWSClient(SSMClient);
     return ssm.send(new PutParameterCommand({
         Name: name,
         Value: value,
@@ -201,6 +203,7 @@ function putParameter(name, value) {
     }));
 }
 function deleteParameter(name) {
+    const ssm = useAWSClient(SSMClient);
     return ssm.send(new DeleteParameterCommand({
         Name: name,
     }));

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/constructs/Service.js

@@ -342,24 +342,38 @@ export class Service extends Construct {
     /////////////////////
     validateServiceExists() {
         const { path: servicePath, file } = this.props;
+        // Validate path exists
         if (!fs.existsSync(servicePath)) {
-            throw new Error(`No service found at "${path.resolve(servicePath)}"`);
+            throw new VisibleError(`In the "${this.node.id}" Service, path is not found at "${path.resolve(servicePath)}"`);
         }
+        // Validate path is a directory
+        if (fs.statSync(servicePath).isFile()) {
+            throw new VisibleError([
+                `In the "${this.node.id}" Service, the path "${path.resolve(servicePath)}" should be a directory.`,
+                `Did you mean:`,
+                ``,
+                `  {`,
+                `    path: "${path.dirname(servicePath)}",`,
+                `    file: "${path.basename(servicePath)}",`,
+                `  }`,
+            ].join("\n"));
+        }
+        // Validate path exists
         if (file) {
             const dockerfilePath = path.join(servicePath, file);
             if (!fs.existsSync(dockerfilePath)) {
-                throw new Error(`No Dockerfile found at "${dockerfilePath}". Make sure to set the "file" property to the path of the Dockerfile relative to "${servicePath}".`);
+                throw new VisibleError(`In the "${this.node.id}" Service, no Dockerfile is found at "${dockerfilePath}". Make sure to set the "file" property to the path of the Dockerfile relative to "${servicePath}".`);
             }
         }
     }
     validateMemoryAndCpu() {
         const { memory, cpu } = this.props;
         if (!supportedCpus[cpu]) {
-            throw new Error(`Only the following "cpu" settings are supported for the ${this.node.id} service: ${Object.keys(supportedCpus).join(", ")}`);
+            throw new VisibleError(`In the "${this.node.id}" Service, only the following "cpu" settings are supported: ${Object.keys(supportedCpus).join(", ")}`);
         }
         // @ts-ignore
         if (!supportedMemories[cpu][memory]) {
-            throw new Error(`Only the following "memory" settings are supported with "${cpu}" for the ${this.node.id} service: ${Object.keys(supportedMemories[cpu]).join(", ")}`);
+            throw new VisibleError(`In the "${this.node.id}" Service, only the following "memory" settings are supported with "${cpu}": ${Object.keys(supportedMemories[cpu]).join(", ")}`);
         }
     }
     createVpc() {

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.19",
+  "version": "2.24.21",
   "bin": {
     "sst": "cli/sst.js"
   },