sst 2.38.7 → 2.38.8

package/constructs/EdgeFunction.d.ts

@@ -2,7 +2,7 @@ import { Construct, IConstruct } from "constructs";
 import { Role } from "aws-cdk-lib/aws-iam";
 import { IVersion, IFunction as CdkIFunction } from "aws-cdk-lib/aws-lambda";
 import { SSTConstruct } from "./Construct.js";
-import { NodeJSProps } from "./Function.js";
+import { NodeJSProps, FunctionCopyFilesProps } from "./Function.js";
 import { Size } from "./util/size.js";
 import { Duration } from "./util/duration.js";
 import { Permissions } from "./util/permission.js";
@@ -16,6 +16,7 @@ export interface EdgeFunctionProps {
     environment?: Record<string, string>;
     bind?: SSTConstruct[];
     nodejs?: NodeJSProps;
+    copyFiles?: FunctionCopyFilesProps[];
     scopeOverride?: IConstruct;
 }
 export declare class EdgeFunction extends Construct {

package/constructs/EdgeFunction.js

@@ -12,7 +12,7 @@ import { Lazy, Duration as CdkDuration, CustomResource, } from "aws-cdk-lib/core
 import { useProject } from "../project.js";
 import { useRuntimeHandlers } from "../runtime/handlers.js";
 import { Stack } from "./Stack.js";
-import { useFunctions } from "./Function.js";
+import { useFunctions, } from "./Function.js";
 import { bindEnvironment, bindPermissions, getReferencedSecrets, } from "./util/functionBinding.js";
 import { toCdkSize } from "./util/size.js";
 import { toCdkDuration } from "./util/duration.js";
@@ -43,10 +43,10 @@ export class EdgeFunction extends Construct {
         //       them.
         this.scope = props.scopeOverride || this;
         this.props = {
-            ...props,
             runtime: "nodejs18.x",
             timeout: 10,
             memorySize: 1024,
+            ...props,
             environment: props.environment || {},
             permissions: props.permissions || [],
         };
@@ -96,7 +96,7 @@ export class EdgeFunction extends Construct {
         }));
     }
     async buildAssetFromHandler() {
-        const { nodejs } = this.props;
+        const { nodejs, copyFiles } = this.props;
         useFunctions().add(this.node.addr, {
             ...this.props,
             architecture: "x86_64",
@@ -107,6 +107,7 @@ export class EdgeFunction extends Construct {
                     nodejs?.banner || "",
                 ].join("\n"),
             },
+            copyFiles,
         });
         // Build function
         const result = await useRuntimeHandlers().build(this.node.addr, "deploy");

package/constructs/Job.d.ts

@@ -1,5 +1,6 @@
 import { Construct } from "constructs";
 import { Function as CdkFunction } from "aws-cdk-lib/aws-lambda";
+import { Project } from "aws-cdk-lib/aws-codebuild";
 import { RetentionDays } from "aws-cdk-lib/aws-logs";
 import { SSTConstruct } from "./Construct.js";
 import { NodeJSProps, FunctionCopyFilesProps } from "./Function.js";
@@ -321,6 +322,9 @@ export declare class Job extends Construct implements SSTConstruct {
      * ```
      */
     addEnvironment(name: string, value: string): void;
+    get cdk(): {
+        codeBuildProject: Project;
+    };
     private createCodeBuildJob;
     private createLiveDevJob;
     private createLogRetention;

package/constructs/Job.js

@@ -135,6 +135,11 @@ export class Job extends Construct {
         this.liveDevJob?.addEnvironment(name, value);
         this.addEnvironmentForCodeBuild(name, value);
     }
+    get cdk() {
+        return {
+            codeBuildProject: this.job,
+        };
+    }
     createCodeBuildJob() {
         const { cdk, runtime, handler, memorySize, timeout, container } = this.props;
         const app = this.node.root;

package/constructs/SsrSite.js

@@ -411,6 +411,7 @@ function handler(event) {
                         ...environment,
                         ...props.environment,
                     },
+                    ...cdk?.server,
                 });
                 bucket.grantReadWrite(fn.role);
                 functions[name] = fn;

package/iot.js

@@ -100,6 +100,7 @@ export const useIOT = lazy(async () => {
         secretKey: creds.secretAccessKey,
         sessionToken: creds.sessionToken,
         reconnectPeriod: 1,
+        keepalive: 60,
     });
     const PREFIX = `/sst/${project.config.name}/${project.config.stage}`;
     device.subscribe(`${PREFIX}/events`, { qos: 1 });

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

@@ -3,7 +3,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";
+import { ZodObject, ZodSchema, z } from "zod";
 /**
  * PutEventsCommandOutput is used in return type of createEvent, in case the consumer of SST builds
  * their project with declaration files, this is not portable. In order to allow TS to generate a
@@ -12,34 +12,60 @@ import { ZodAny, ZodObject, ZodRawShape, z } from "zod";
  * More information here: https://github.com/microsoft/TypeScript/issues/47663#issuecomment-1519138189
  */
 export { PutEventsCommandOutput };
-export declare function createEventBuilder<Bus extends keyof typeof EventBus, MetadataShape extends ZodRawShape | undefined, MetadataFunction extends () => any>(props: {
+export declare function createEventBuilder<Bus extends keyof typeof EventBus, MetadataFunction extends () => any, Validator extends (schema: any) => (input: any) => any, MetadataSchema extends Parameters<Validator>[0]>(input: {
     bus: Bus;
-    metadata?: MetadataShape;
+    metadata?: MetadataSchema;
     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<PutEventsCommandOutput> : (properties: Properties, metadata: z.infer<ZodObject<Exclude<MetadataShape, undefined>, "strip", ZodAny>>) => Promise<void>;
+    validator: Validator;
+}): <Type extends string, Schema extends Parameters<Validator>[0]>(type: Type, schema: Schema) => {
+    publish: undefined extends MetadataSchema ? (properties: inferParser<Schema>["in"]) => Promise<PutEventsCommandOutput> : (properties: inferParser<Schema>["in"], metadata: inferParser<MetadataSchema>["in"]) => Promise<void>;
     type: Type;
-    shape: {
-        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>;
+    $input: inferParser<Schema>["in"];
+    $output: inferParser<Schema>["out"];
+    $metadata: ReturnType<MetadataFunction>;
+};
+export declare function ZodValidator<Schema extends ZodSchema>(schema: Schema): (input: z.input<Schema>) => z.output<Schema>;
+export type ParserZodEsque<TInput, TParsedInput> = {
+    _input: TInput;
+    _output: TParsedInput;
+};
+export type ParserValibotEsque<TInput, TParsedInput> = {
+    _types?: {
+        input: TInput;
+        output: TParsedInput;
     };
 };
+export type ParserMyZodEsque<TInput> = {
+    parse: (input: any) => TInput;
+};
+export type ParserSuperstructEsque<TInput> = {
+    create: (input: unknown) => TInput;
+};
+export type ParserCustomValidatorEsque<TInput> = (input: unknown) => Promise<TInput> | TInput;
+export type ParserYupEsque<TInput> = {
+    validateSync: (input: unknown) => TInput;
+};
+export type ParserScaleEsque<TInput> = {
+    assert(value: unknown): asserts value is TInput;
+};
+export type ParserWithoutInput<TInput> = ParserCustomValidatorEsque<TInput> | ParserMyZodEsque<TInput> | ParserScaleEsque<TInput> | ParserSuperstructEsque<TInput> | ParserYupEsque<TInput>;
+export type ParserWithInputOutput<TInput, TParsedInput> = ParserZodEsque<TInput, TParsedInput> | ParserValibotEsque<TInput, TParsedInput>;
+export type Parser = ParserWithInputOutput<any, any> | ParserWithoutInput<any>;
+export type inferParser<TParser extends Parser> = TParser extends ParserWithInputOutput<infer $TIn, infer $TOut> ? {
+    in: $TIn;
+    out: $TOut;
+} : TParser extends ParserWithoutInput<infer $InOut> ? {
+    in: $InOut;
+    out: $InOut;
+} : never;
 export type inferEvent<T extends {
     shape: ZodObject<any>;
 }> = z.infer<T["shape"]>;
-type Event = {
-    type: string;
-    shape: {
-        properties: any;
-        metadata: any;
-        metadataFn: any;
-    };
-};
-export type EventPayload<E extends Event> = {
+type Event = ReturnType<ReturnType<typeof createEventBuilder>>;
+type EventPayload<E extends Event> = {
     type: E["type"];
-    properties: E["shape"]["properties"];
-    metadata: undefined extends E["shape"]["metadata"] ? E["shape"]["metadataFn"] : E["shape"]["metadata"];
+    properties: E["$output"];
+    metadata: E["$metadata"];
     attempts: number;
 };
 export declare function EventHandler<Events extends Event>(_events: Events | Events[], cb: (evt: {

package/node/event-bus/index.js

@@ -2,17 +2,15 @@ import { createProxy } from "../util/index.js";
 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) {
-        const propertiesSchema = z.object(properties);
-        const metadataSchema = props.metadata
-            ? z.object(props.metadata)
-            : undefined;
-        const publish = async (properties, metadata) => {
+export function createEventBuilder(input) {
+    const client = new EventBridgeClient({});
+    const validator = input.validator;
+    const metadataValidator = input.metadata ? validator(input.metadata) : null;
+    return function event(type, schema) {
+        const validate = validator(schema);
+        async function publish(properties, metadata) {
             const result = await useLoader("sst.bus.publish", async (input) => {
                 const size = 10;
                 const promises = [];
@@ -39,31 +37,34 @@ export function createEventBuilder(props) {
                 // @ts-expect-error
                 Source: Config.APP,
                 Detail: JSON.stringify({
-                    properties: propertiesSchema.parse(properties),
+                    properties: validate(properties),
                     metadata: (() => {
-                        if (metadataSchema) {
-                            return metadataSchema.parse(metadata);
+                        if (metadataValidator) {
+                            return metadataValidator(metadata);
                         }
-                        if (props.metadataFn) {
-                            return props.metadataFn();
+                        if (input.metadataFn) {
+                            return input.metadataFn();
                         }
                     })(),
                 }),
                 DetailType: type,
             });
             return result;
-        };
+        }
         return {
             publish: publish,
             type,
-            shape: {
-                metadata: {},
-                properties: {},
-                metadataFn: {},
-            },
+            $input: {},
+            $output: {},
+            $metadata: {},
         };
     };
 }
+export function ZodValidator(schema) {
+    return (input) => {
+        return schema.parse(input);
+    };
+}
 export function EventHandler(_events, cb) {
     return async (event) => {
         await cb({

package/package.json

@@ -1,7 +1,7 @@
 {
   "sideEffects": false,
   "name": "sst",
-  "version": "2.38.7",
+  "version": "2.38.8",
   "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.38.7",
+    "astro-sst": "2.38.8",
     "async": "^3.2.4",
     "tsx": "^3.12.1",
     "typescript": "^5.2.2",

package/runtime/handlers/node.js

@@ -206,23 +206,26 @@ export const useNodeHandler = () => {
                     await fs.writeFile(path.join(input.out, "package.json"), JSON.stringify({
                         dependencies: Object.fromEntries(installPackages.map((x) => [x, json.dependencies?.[x] || "*"])),
                     }));
-                    const cmd = ["npm install"];
+                    const cmd = [
+                        "npm install",
+                        "--platform=linux",
+                        "--omit=dev",
+                        "--no-optional",
+                        input.props.architecture === "arm_64"
+                            ? "--arch=arm64"
+                            : "--arch=x64",
+                    ];
                     if (installPackages.includes("sharp")) {
                         /**
                          * TODO: This is a workaround for issues that sharp v0.33.0 has
                          * with cross platform builds. This can be removed once sharp
                          * releases a new version with the fix.
                          */
-                        cmd.push("--platform=linux", "--omit=dev", "--no-optional", input.props.architecture === "arm_64"
-                            ? "--arch=arm64"
-                            : "--arch=x64", "--force sharp@0.32.6");
+                        cmd.push("--force sharp@0.32.6");
                         /**
                          * Once the above issue is resolved, the code below can be used.
                          */
                         // cmd.push(
-                        //   "--platform=linux",
-                        //   "--omit=dev",
-                        //   "--no-optional",
                         //   ...input.props.architecture === "arm_64"
                         //     ? ["--arch=arm64", "--force @img/sharp-linux-arm64"]
                         //     : ["--arch=x64", "--force @img/sharp-linux-x64"],