sst 2.24.10 → 2.24.12

package/bootstrap.js

@@ -161,10 +161,12 @@ export async function bootstrapSST(cdkBucket) {
         },
         synthesizer: new DefaultStackSynthesizer({
             qualifier: cdk?.qualifier,
+            bootstrapStackVersionSsmParameter: cdk?.bootstrapStackVersionSsmParameter,
             fileAssetsBucketName: cdk?.fileAssetsBucketName,
             deployRoleArn: cdk?.deployRoleArn,
             fileAssetPublishingRoleArn: cdk?.fileAssetPublishingRoleArn,
             imageAssetPublishingRoleArn: cdk?.imageAssetPublishingRoleArn,
+            imageAssetsRepositoryName: cdk?.imageAssetsRepositoryName,
             cloudFormationExecutionRole: cdk?.cloudFormationExecutionRole,
             lookupRoleArn: cdk?.lookupRoleArn,
         }),

package/constructs/Stack.js

@@ -205,10 +205,12 @@ export class Stack extends CDKStack {
         const { config } = useProject();
         const props = {
             qualifier: config.cdk?.qualifier,
+            bootstrapStackVersionSsmParameter: config.cdk?.bootstrapStackVersionSsmParameter,
             fileAssetsBucketName: config.cdk?.fileAssetsBucketName,
             deployRoleArn: config.cdk?.deployRoleArn,
             fileAssetPublishingRoleArn: config.cdk?.fileAssetPublishingRoleArn,
             imageAssetPublishingRoleArn: config.cdk?.imageAssetPublishingRoleArn,
+            imageAssetsRepositoryName: config.cdk?.imageAssetsRepositoryName,
             cloudFormationExecutionRole: config.cdk?.cloudFormationExecutionRole,
             lookupRoleArn: config.cdk?.lookupRoleArn,
         };

package/node/event-bus/index.d.ts

@@ -1,6 +1,7 @@
 export interface EventBusResources {
 }
 export declare const EventBus: EventBusResources;
+import { PutEventsCommandOutput } from "@aws-sdk/client-eventbridge";
 import { EventBridgeEvent } from "aws-lambda";
 import { ZodAny, ZodObject, ZodRawShape, z } from "zod";
 export declare function createEventBuilder<Bus extends keyof typeof EventBus, MetadataShape extends ZodRawShape | undefined, MetadataFunction extends () => any>(props: {
@@ -8,10 +9,10 @@ export declare function createEventBuilder<Bus extends keyof typeof EventBus, Me
     metadata?: MetadataShape;
     metadataFn?: MetadataFunction;
 }): <Type extends string, Shape extends ZodRawShape, Properties = z.objectOutputType<Shape, ZodAny, "strip">>(type: Type, properties: Shape) => {
-    publish: undefined extends MetadataShape ? (properties: Properties) => Promise<void> : (properties: Properties, metadata: z.infer<ZodObject<Exclude<MetadataShape, undefined>, "strip", ZodAny>>) => Promise<void>;
+    publish: undefined extends MetadataShape ? (properties: Properties) => Promise<PutEventsCommandOutput> : (properties: Properties, metadata: z.infer<ZodObject<Exclude<MetadataShape, undefined>, "strip", ZodAny>>) => Promise<void>;
     type: Type;
     shape: {
-        metadata: Parameters<undefined extends MetadataShape ? (properties: Properties) => Promise<void> : (properties: Properties, metadata: z.infer<ZodObject<Exclude<MetadataShape, undefined>, "strip", ZodAny>>) => Promise<void>>[1];
+        metadata: Parameters<undefined extends MetadataShape ? (properties: Properties) => Promise<PutEventsCommandOutput> : (properties: Properties, metadata: z.infer<ZodObject<Exclude<MetadataShape, undefined>, "strip", ZodAny>>) => Promise<void>>[1];
         properties: Properties;
         metadataFn: ReturnType<MetadataFunction>;
     };

package/node/event-bus/index.js

@@ -3,6 +3,8 @@ export const EventBus =
 /* @__PURE__ */ createProxy("EventBus");
 import { EventBridgeClient, PutEventsCommand, } from "@aws-sdk/client-eventbridge";
 import { z } from "zod";
+import { useLoader } from "../util/loader.js";
+import { Config } from "../config/index.js";
 const client = new EventBridgeClient({});
 export function createEventBuilder(props) {
     return function createEvent(type, properties) {
@@ -12,27 +14,45 @@ export function createEventBuilder(props) {
             : undefined;
         const publish = async (properties, metadata) => {
             console.log("publishing", type, properties);
-            await client.send(new PutEventsCommand({
-                Entries: [
-                    {
-                        // @ts-expect-error
-                        EventBusName: EventBus[props.bus].eventBusName,
-                        Source: "console",
-                        Detail: JSON.stringify({
-                            properties: propertiesSchema.parse(properties),
-                            metadata: (() => {
-                                if (metadataSchema) {
-                                    return metadataSchema.parse(metadata);
-                                }
-                                if (props.metadataFn) {
-                                    return props.metadataFn();
-                                }
-                            })(),
-                        }),
-                        DetailType: type,
-                    },
-                ],
-            }));
+            const result = await useLoader("sst.bus.publish", async (input) => {
+                const size = 10;
+                const promises = [];
+                for (let i = 0; i < input.length; i += size) {
+                    const chunk = input.slice(i, i + size);
+                    promises.push(client.send(new PutEventsCommand({
+                        Entries: chunk,
+                    })));
+                }
+                const settled = await Promise.allSettled(promises);
+                const result = new Array(input.length);
+                for (let i = 0; i < result.length; i++) {
+                    const item = settled[Math.floor(i / 10)];
+                    if (item.status === "rejected") {
+                        result[i] = item.reason;
+                        continue;
+                    }
+                    result[i] = item.value;
+                }
+                return result;
+            })({
+                // @ts-expect-error
+                EventBusName: EventBus[props.bus].eventBusName,
+                // @ts-expect-error
+                Source: Config.APP,
+                Detail: JSON.stringify({
+                    properties: propertiesSchema.parse(properties),
+                    metadata: (() => {
+                        if (metadataSchema) {
+                            return metadataSchema.parse(metadata);
+                        }
+                        if (props.metadataFn) {
+                            return props.metadataFn();
+                        }
+                    })(),
+                }),
+                DetailType: type,
+            });
+            return result;
         };
         return {
             publish: publish,

package/node/service/index.d.ts

@@ -0,0 +1,3 @@
+export interface ServiceResources {
+}
+export declare const Service: ServiceResources;

package/node/service/index.js

@@ -0,0 +1,4 @@
+import { createProxy } from "../util/index.js";
+export const Service = 
+/* @__PURE__ */
+createProxy("Service");

package/node/util/loader.d.ts

@@ -0,0 +1,2 @@
+export declare function createLoader<Key, Value>(batchFn: (keys: Key[]) => Promise<Value[]>): (key: Key) => Promise<Value>;
+export declare function useLoader<Key, Value>(key: any, batchFn: (keys: Key[]) => Promise<Value[]>): (key: Key) => Promise<Value>;

package/node/util/loader.js

@@ -0,0 +1,51 @@
+import { Context } from "../../context/context.js";
+const LoaderContext = Context.create(() => {
+    const loaders = new Map();
+    return loaders;
+}, "loader-context");
+export function createLoader(batchFn) {
+    let current;
+    async function run() {
+        const batch = current;
+        if (!batch)
+            return;
+        const result = await batchFn(batch.keys);
+        for (let i = 0; i < result.length; i++) {
+            batch.promises[i](result[i]);
+        }
+        current = undefined;
+    }
+    function getBatch() {
+        if (current)
+            return current;
+        process.nextTick(run);
+        current = {
+            keys: [],
+            promises: [],
+        };
+        return current;
+    }
+    return (key) => {
+        const batch = getBatch();
+        batch.keys.push(key);
+        const promise = new Promise((resolve, reject) => {
+            batch.promises.push((val) => {
+                if (val instanceof Error) {
+                    reject(val);
+                    return;
+                }
+                resolve(val);
+            });
+        });
+        return promise;
+    };
+}
+export function useLoader(key, batchFn) {
+    const loaders = LoaderContext.use();
+    if (loaders.has(key)) {
+        return loaders.get(key);
+    }
+    const loader = createLoader(batchFn);
+    loaders.set(key, loader);
+    return loader;
+}

package/package.json

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

package/project.d.ts

@@ -24,12 +24,14 @@ export interface ConfigOptions {
     cdk?: {
         toolkitStackName?: string;
         qualifier?: string;
+        bootstrapStackVersionSsmParameter?: string;
         fileAssetsBucketName?: string;
         customPermissionsBoundary?: string;
         publicAccessBlockConfiguration?: boolean;
         deployRoleArn?: string;
         fileAssetPublishingRoleArn?: string;
         imageAssetPublishingRoleArn?: string;
+        imageAssetsRepositoryName?: string;
         cloudFormationExecutionRole?: string;
         lookupRoleArn?: string;
         pathMetadata?: boolean;