sst 3.0.23 → 3.0.25

package/dist/aws/bus.d.ts

@@ -7,14 +7,19 @@ export declare namespace bus {
     type Name = Extract<typeof Resource, {
         type: "sst.aws.Bus";
     }>["name"];
-    function handle<Events extends event.Definition>(_events: Events | Events[], cb: (input: {
+    function subscriber<Events extends event.Definition>(_events: Events | Events[], cb: (input: {
         [K in Events["type"]]: Extract<Events, {
             type: K;
         }>["$payload"];
     }[Events["type"]], raw: EventBridgeEvent<string, any>) => Promise<void>): EventBridgeHandler<string, any, void>;
-    function publish<Definition extends event.Definition>(name: string | {
+    /** @deprecated
+     * use bus.subscriber instead
+     * */
+    const handler: typeof subscriber;
+    function publish<Definition extends event.Definition = any>(name: string | {
         name: string;
-    }, def: Definition, properties: Definition["$input"], options?: {
+    }, def: Definition | string, properties: Definition["$input"], options?: {
+        metadata?: Definition["$metadata"];
         aws?: AwsOptions;
     }): Promise<any>;
     class PublishError extends Error {

package/dist/aws/bus.js

@@ -6,7 +6,7 @@ export var bus;
         const region = options?.region || client.region;
         return `https://events.${region}.amazonaws.com/`;
     }
-    function handle(_events, cb) {
+    function subscriber(_events, cb) {
         return async function (event) {
             const payload = {
                 type: event["detail-type"],
@@ -16,10 +16,20 @@ export var bus;
             return cb(payload, event);
         };
     }
-    bus.handle = handle;
+    bus.subscriber = subscriber;
+    /** @deprecated
+     * use bus.subscriber instead
+     * */
+    bus.handler = subscriber;
     async function publish(name, def, properties, options) {
         const u = url(options?.aws);
-        const evt = await def.create(properties);
+        const evt = typeof def === "string"
+            ? {
+                type: def,
+                properties,
+                metadata: options?.metadata || {},
+            }
+            : await def.create(properties);
         const res = await client.fetch(u, {
             method: "POST",
             aws: options?.aws,

package/dist/event/index.d.ts

@@ -8,20 +8,19 @@ export declare namespace event {
         $payload: any;
         create: (...args: any[]) => Promise<any>;
     };
-    export function builder<MetadataFunction extends (type: string, properties: any) => any, Validator extends (schema: any) => (input: any) => any, MetadataSchema extends Parameters<Validator>[0] | undefined>(input: {
-        metadata?: MetadataSchema;
-        metadataFn?: MetadataFunction;
-        validator: Validator;
+    export function builder<Metadata extends ((type: string, properties: any) => any) | Parameters<Validator>[0], Validator extends (schema: any) => (input: any) => any = typeof ZodValidator>(input: {
+        validator?: Validator;
+        metadata?: Metadata;
     }): {
         <Type extends string, Schema extends Parameters<Validator>[0]>(type: Type, schema: Schema): {
-            create: undefined extends MetadataSchema ? (properties: inferParser<Schema>["in"]) => Promise<{
+            create: Metadata extends (type: string, properties: any) => any ? (properties: inferParser<Schema>["in"]) => Promise<{
                 type: Type;
                 properties: inferParser<Schema>["out"];
-                metadata: ReturnType<MetadataFunction>;
-            }> : (properties: inferParser<Schema>["in"], metadata: inferParser<MetadataSchema>["in"]) => Promise<{
+                metadata: Metadata extends (type: string, properties: any) => any ? ReturnType<Metadata> : inferParser<Metadata>["out"];
+            }> : (properties: inferParser<Schema>["in"], metadata: inferParser<Metadata>["in"]) => Promise<{
                 type: Type;
                 properties: inferParser<Schema>["out"];
-                metadata: ReturnType<MetadataFunction>;
+                metadata: Metadata extends (type: string, properties: any) => any ? ReturnType<Metadata> : inferParser<Metadata>["out"];
             }>;
             type: Type;
             $input: inferParser<Schema>["in"];
@@ -29,9 +28,9 @@ export declare namespace event {
             $payload: {
                 type: Type;
                 properties: inferParser<Schema>["out"];
-                metadata: ReturnType<MetadataFunction>;
+                metadata: Metadata extends (type: string, properties: any) => any ? ReturnType<Metadata> : inferParser<Metadata>["out"];
             };
-            $metadata: ReturnType<MetadataFunction>;
+            $metadata: Metadata extends (type: string, properties: any) => any ? ReturnType<Metadata> : inferParser<Metadata>["out"];
         };
         coerce<Events extends Definition>(_events: Events | Events[], raw: any): { [K in Events["type"]]: Extract<Events, {
             type: K;

package/dist/event/index.js

@@ -1,17 +1,15 @@
 export var event;
 (function (event) {
     function builder(input) {
-        const validator = input.validator;
-        const metadataValidator = input.metadata ? validator(input.metadata) : null;
+        const validator = input.validator || ZodValidator;
         const fn = function event(type, schema) {
             const validate = validator(schema);
             async function create(properties, metadata) {
-                if (metadataValidator) {
-                    metadata = metadataValidator(metadata);
-                }
-                if (input.metadataFn) {
-                    metadata = input.metadataFn(type, properties);
-                }
+                metadata = input.metadata
+                    ? typeof input.metadata === "function"
+                        ? input.metadata(type, properties)
+                        : input.metadata(metadata)
+                    : {};
                 properties = validate(properties);
                 return {
                     type,

package/package.json

@@ -3,7 +3,7 @@
   "name": "sst",
   "type": "module",
   "sideEffects": false,
-  "version": "3.0.23",
+  "version": "3.0.25",
   "main": "./dist/index.js",
   "exports": {
     ".": "./dist/index.js",

package/dist/event/bus.d.ts

@@ -1,20 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-import { AwsOptions } from "../aws/client.js";
-import { Resource } from "../resource.js";
-import { EventDefinition } from "./event.js";
-import { EventBridgeEvent, EventBridgeHandler } from "aws-lambda";
-export declare namespace bus {
-    type Name = Extract<typeof Resource, {
-        type: "sst.aws.Bus";
-    }>["name"];
-    function handle<Events extends EventDefinition>(_events: Events | Events[], cb: (input: {
-        [K in Events["type"]]: Extract<Events, {
-            type: K;
-        }>["$payload"];
-    }[Events["type"]], raw: EventBridgeEvent<string, any>) => Promise<void>): EventBridgeHandler<string, any, void>;
-    function publish<N extends Name, Definition extends EventDefinition>(name: N, def: Definition, properties: Definition["$input"], options?: AwsOptions): Promise<unknown>;
-    class PublishError extends Error {
-        readonly response: Response;
-        constructor(response: Response);
-    }
-}

package/dist/event/bus.js

@@ -1,57 +0,0 @@
-import { client } from "../aws/client.js";
-import { Resource } from "../resource.js";
-export var bus;
-(function (bus) {
-    function url(options) {
-        const region = options?.region || client.region;
-        return `https://events.${region}.amazonaws.com/`;
-    }
-    function handle(_events, cb) {
-        return async function (event) {
-            const payload = {
-                type: event["detail-type"],
-                properties: event.detail.properties,
-                metadata: event.detail.metadata,
-            };
-            return cb(payload, event);
-        };
-    }
-    bus.handle = handle;
-    async function publish(name, def, properties, options) {
-        const u = url(options);
-        const evt = await def.create(properties);
-        const res = await client.fetch(u, {
-            method: "POST",
-            aws: options,
-            headers: {
-                "X-Amz-Target": "AWSEvents.PutEvents",
-                "Content-Type": "application/x-amz-json-1.1",
-            },
-            body: JSON.stringify({
-                Entries: [
-                    {
-                        Source: [Resource.App.name, Resource.App.stage].join("."),
-                        DetailType: evt.type,
-                        Detail: JSON.stringify({
-                            metadata: evt.metadata,
-                            payload: evt.properties,
-                        }),
-                        EventBusName: name,
-                    },
-                ],
-            }),
-        });
-        if (!res.ok)
-            throw new PublishError(res);
-        return res.json();
-    }
-    bus.publish = publish;
-    class PublishError extends Error {
-        response;
-        constructor(response) {
-            super("Failed to publish event to bus");
-            this.response = response;
-        }
-    }
-    bus.PublishError = PublishError;
-})(bus || (bus = {}));

package/dist/event/destination.d.ts

@@ -1,19 +0,0 @@
-import { Prettify } from "../util/prettify.js";
-export interface Payload {
-    type: string;
-    properties: any;
-    metadata: any;
-}
-declare const Publishers: {
-    "sst.aws.Bus": (properties: {
-        name: string;
-    }, payload: Payload) => void;
-};
-type Publishers = typeof Publishers;
-export type Destinations = {
-    [key in keyof Publishers]: Prettify<{
-        type: key;
-    } & Parameters<Publishers[key]>[0]>;
-}[keyof Publishers];
-export declare function publish(destination: Destinations, payload: Payload): void;
-export {};

package/dist/event/destination.js

@@ -1,6 +0,0 @@
-const Publishers = {
-    "sst.aws.Bus": (properties, payload) => { },
-};
-export function publish(destination, payload) {
-    return Publishers[destination.type](destination, payload);
-}

package/dist/event/event.d.ts

@@ -1,75 +0,0 @@
-import { ZodSchema, z } from "zod";
-export declare namespace event {
-    export type Definition = {
-        type: string;
-        $input: any;
-        $output: any;
-        $metadata: any;
-        $payload: any;
-        create: (...args: any[]) => Promise<any>;
-    };
-    export function builder<MetadataFunction extends (type: string, properties: any) => any, Validator extends (schema: any) => (input: any) => any, MetadataSchema extends Parameters<Validator>[0] | undefined>(input: {
-        metadata?: MetadataSchema;
-        metadataFn?: MetadataFunction;
-        validator: Validator;
-    }): {
-        <Type extends string, Schema extends Parameters<Validator>[0]>(type: Type, schema: Schema): {
-            create: undefined extends MetadataSchema ? (properties: inferParser<Schema>["in"]) => Promise<{
-                type: Type;
-                properties: inferParser<Schema>["out"];
-                metadata: ReturnType<MetadataFunction>;
-            }> : (properties: inferParser<Schema>["in"], metadata: inferParser<MetadataSchema>["in"]) => Promise<{
-                type: Type;
-                properties: inferParser<Schema>["out"];
-                metadata: ReturnType<MetadataFunction>;
-            }>;
-            type: Type;
-            $input: inferParser<Schema>["in"];
-            $output: inferParser<Schema>["out"];
-            $payload: {
-                type: Type;
-                properties: inferParser<Schema>["out"];
-                metadata: ReturnType<MetadataFunction>;
-            };
-            $metadata: ReturnType<MetadataFunction>;
-        };
-        coerce<Events extends Definition>(_events: Events | Events[], raw: any): { [K in Events["type"]]: Extract<Events, {
-            type: K;
-        }>["$payload"]; }[Events["type"]];
-    };
-    export function ZodValidator<Schema extends ZodSchema>(schema: Schema): (input: z.input<Schema>) => z.output<Schema>;
-    type ParserZodEsque<TInput, TParsedInput> = {
-        _input: TInput;
-        _output: TParsedInput;
-    };
-    type ParserValibotEsque<TInput, TParsedInput> = {
-        _types?: {
-            input: TInput;
-            output: TParsedInput;
-        };
-    };
-    type ParserMyZodEsque<TInput> = {
-        parse: (input: any) => TInput;
-    };
-    type ParserSuperstructEsque<TInput> = {
-        create: (input: unknown) => TInput;
-    };
-    type ParserCustomValidatorEsque<TInput> = (input: unknown) => Promise<TInput> | TInput;
-    type ParserYupEsque<TInput> = {
-        validateSync: (input: unknown) => TInput;
-    };
-    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 {};
-}

package/dist/event/event.js

@@ -1,43 +0,0 @@
-export var event;
-(function (event) {
-    function builder(input) {
-        const validator = input.validator;
-        const metadataValidator = input.metadata ? validator(input.metadata) : null;
-        const fn = function event(type, schema) {
-            const validate = validator(schema);
-            async function create(properties, metadata) {
-                if (metadataValidator) {
-                    metadata = metadataValidator(metadata);
-                }
-                if (input.metadataFn) {
-                    metadata = input.metadataFn(type, properties);
-                }
-                properties = validate(properties);
-                return {
-                    type,
-                    properties,
-                    metadata,
-                };
-            }
-            return {
-                create: create,
-                type,
-                $input: {},
-                $output: {},
-                $payload: {},
-                $metadata: {},
-            };
-        };
-        fn.coerce = (_events, raw) => {
-            return raw;
-        };
-        return fn;
-    }
-    event.builder = builder;
-    function ZodValidator(schema) {
-        return (input) => {
-            return schema.parse(input);
-        };
-    }
-    event.ZodValidator = ZodValidator;
-})(event || (event = {}));

package/dist/vector-client.d.ts

@@ -1,186 +0,0 @@
-import { Resource } from "./resource.js";
-export type IngestEvent = {
-    /**
-     * The text used to generate the embedding vector.
-     * At least one of `text` or `image` must be provided.
-     * @example
-     * ```js
-     * {
-     *   text: "This is an example text.",
-     * }
-     * ```
-     */
-    text?: string;
-    /**
-     * The base64 representation of the image used to generate the embedding vector.
-     * At least one of `text` or `image` must be provided.
-     * @example
-     * ```js
-     * {
-     *   image: await fs.readFile("./file.jpg").toString("base64"),
-     * }
-     * ```
-     */
-    image?: string;
-    /**
-     * Metadata for the event in JSON format.
-     * This metadata will be used to filter when retrieving and removing embeddings.
-     * @example
-     * ```js
-     * {
-     *   metadata: {
-     *     type: "movie",
-     *     id: "movie-123",
-     *     name: "Spiderman",
-     *   }
-     * }
-     * ```
-     */
-    metadata: Record<string, any>;
-};
-export type RetrieveEvent = {
-    /**
-     * The text prompt used to retrieve embeddings.
-     * At least one of `text` or `image` must be provided.
-     * @example
-     * ```js
-     * {
-     *   text: "This is an example text.",
-     * }
-     * ```
-     */
-    text?: string;
-    /**
-     * The base64 representation of the image prompt used to retrive embeddings.
-     * At least one of `text` or `image` must be provided.
-     * @example
-     * ```js
-     * {
-     *   image: await fs.readFile("./file.jpg").toString("base64"),
-     * }
-     * ```
-     */
-    image?: string;
-    /**
-     * The metadata used to filter the retrieval of embeddings.
-     * Only embeddings with metadata that match the provided fields will be returned.
-     * @example
-     * ```js
-     * {
-     *   include: {
-     *     type: "movie",
-     *     release: "2001",
-     *   }
-     * }
-     * ```
-     * This will match the embedding with metadata:
-     *  {
-     *    type: "movie",
-     *    name: "Spiderman",
-     *    release: "2001",
-     *  }
-     *
-     * But not the embedding with metadata:
-     *  {
-     *    type: "book",
-     *    name: "Spiderman",
-     *    release: "2001",
-     *  }
-     */
-    include: Record<string, any>;
-    /**
-     * Exclude embeddings with metadata that match the provided fields.
-     * @example
-     * ```js
-     * {
-     *   include: {
-     *     type: "movie",
-     *     release: "2001",
-     *   },
-     *   exclude: {
-     *     name: "Spiderman",
-     *   }
-     * }
-     * ```
-     * This will match the embedding with metadata:
-     *  {
-     *    type: "movie",
-     *    name: "A Beautiful Mind",
-     *    release: "2001",
-     *  }
-     *
-     * But not the embedding with metadata:
-     *  {
-     *    type: "book",
-     *    name: "Spiderman",
-     *    release: "2001",
-     *  }
-     */
-    exclude?: Record<string, any>;
-    /**
-     * The threshold of similarity between the prompt and the retrieved embeddings.
-     * Only embeddings with a similarity score higher than the threshold will be returned.
-     * Expected value is between 0 and 1.
-     * - 0 means the prompt and the retrieved embeddings are completely different.
-     * - 1 means the prompt and the retrieved embeddings are identical.
-     * @default `0`
-     * @example
-     * ```js
-     * {
-     *   threshold: 0.5,
-     * }
-     * ```
-     */
-    threshold?: number;
-    /**
-     * The number of results to return.
-     * @default `10`
-     * @example
-     * ```js
-     * {
-     *   count: 10,
-     * }
-     * ```
-     */
-    count?: number;
-};
-export type RemoveEvent = {
-    /**
-     * The metadata used to filter the removal of embeddings.
-     * Only embeddings with metadata that match the provided fields will be removed.
-     * @example
-     * To remove embeddings for movie with id "movie-123":
-     * ```js
-     * {
-     *   include: {
-     *     id: "movie-123",
-     *   }
-     * }
-     * ```
-     * To remove embeddings for all movies:
-     *  {
-     *   include: {
-     *    type: "movie",
-     *   }
-     *  }
-     */
-    include: Record<string, any>;
-};
-type RetriveResponse = {
-    /**
-     * Metadata for the event in JSON format that was provided when ingesting the embedding.
-     */
-    metadata: Record<string, any>;
-    /**
-     * The similarity score between the prompt and the retrieved embedding.
-     */
-    score: number;
-};
-export declare function VectorClient<T extends keyof {
-    [key in keyof Resource as "sst.aws.Vector" extends Resource[key]["type"] ? string extends key ? never : key : never]: Resource[key];
-}>(name: T): {
-    ingest: (event: IngestEvent) => Promise<void>;
-    retrieve: (event: RetrieveEvent) => Promise<RetriveResponse>;
-    remove: (event: RemoveEvent) => Promise<void>;
-};
-export {};

package/dist/vector-client.js

@@ -1,41 +0,0 @@
-import { LambdaClient, InvokeCommand, } from "@aws-sdk/client-lambda";
-import { Resource } from "./resource.js";
-const lambda = new LambdaClient();
-export function VectorClient(name) {
-    return {
-        ingest: async (event) => {
-            const ret = await lambda.send(new InvokeCommand({
-                // @ts-expect-error
-                FunctionName: Resource[name].ingestor,
-                Payload: JSON.stringify(event),
-            }));
-            parsePayload(ret, "Failed to ingest into the vector db");
-        },
-        retrieve: async (event) => {
-            const ret = await lambda.send(new InvokeCommand({
-                // @ts-expect-error
-                FunctionName: Resource[name].retriever,
-                Payload: JSON.stringify(event),
-            }));
-            return parsePayload(ret, "Failed to retrieve from the vector db");
-        },
-        remove: async (event) => {
-            const ret = await lambda.send(new InvokeCommand({
-                // @ts-expect-error
-                FunctionName: Resource[name].remover,
-                Payload: JSON.stringify(event),
-            }));
-            parsePayload(ret, "Failed to remove from the vector db");
-        },
-    };
-}
-function parsePayload(output, message) {
-    const payload = JSON.parse(Buffer.from(output.Payload).toString());
-    // Set cause to the payload so that it can be logged in CloudWatch
-    if (output.FunctionError) {
-        const e = new Error(message);
-        e.cause = payload;
-        throw e;
-    }
-    return payload;
-}