sst 3.0.23 → 3.0.24

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/event/index.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/index.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/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./realtime/index.js";
-export * from "./resource.js";
-export * from "./vector/index.js";

package/dist/index.js

@@ -1,3 +0,0 @@
-export * from "./realtime/index.js";
-export * from "./resource.js";
-export * from "./vector/index.js";

package/dist/realtime/index.d.ts

@@ -1,25 +0,0 @@
-import { realtime } from "../aws/realtime.js";
-export type RealtimeAuthResult = realtime.AuthResult;
-/**
- * @deprecated import from `sst/aws/realtime` instead.
- *
- * Creates an authorization handler for the `Realtime` component, that validates
- * the token and grants permissions for the topics the client can subscribe and publish to.
- *
- * @example
- * ```js
- * import { RealtimeAuthHandler, Resource } from "sst";
- *
- * export const handler = RealtimeAuthHandler(async (token) => {
- *   // Validate the token
- *   console.log(token);
- *
- *   // Return the topics to subscribe and publish
- *   return {
- *     subscribe: [`${Resource.App.name}/${Resource.App.stage}/chat/room1`],
- *     publish: [`${Resource.App.name}/${Resource.App.stage}/chat/room1`],
- *   };
- * });
- * ```
- */
-export declare const RealtimeAuthHandler: typeof realtime.authorizer;

package/dist/realtime/index.js

@@ -1,24 +0,0 @@
-import { realtime } from "../aws/realtime.js";
-/**
- * @deprecated import from `sst/aws/realtime` instead.
- *
- * Creates an authorization handler for the `Realtime` component, that validates
- * the token and grants permissions for the topics the client can subscribe and publish to.
- *
- * @example
- * ```js
- * import { RealtimeAuthHandler, Resource } from "sst";
- *
- * export const handler = RealtimeAuthHandler(async (token) => {
- *   // Validate the token
- *   console.log(token);
- *
- *   // Return the topics to subscribe and publish
- *   return {
- *     subscribe: [`${Resource.App.name}/${Resource.App.stage}/chat/room1`],
- *     publish: [`${Resource.App.name}/${Resource.App.stage}/chat/room1`],
- *   };
- * });
- * ```
- */
-export const RealtimeAuthHandler = realtime.authorizer;

package/dist/resource.d.ts

@@ -1,9 +0,0 @@
-export interface Resource {
-    App: {
-        name: string;
-        stage: string;
-    };
-}
-export declare function fromCloudflareEnv(input: any): void;
-export declare function wrapCloudflareHandler(handler: any): any;
-export declare const Resource: Resource;

package/dist/resource.js

@@ -1,50 +0,0 @@
-import { env } from "node:process";
-const raw = {
-    // @ts-expect-error,
-    ...globalThis.$SST_LINKS,
-};
-for (const [key, value] of Object.entries(env)) {
-    if (key.startsWith("SST_RESOURCE_") && value) {
-        raw[key.slice("SST_RESOURCE_".length)] = JSON.parse(value);
-    }
-}
-export function fromCloudflareEnv(input) {
-    for (let [key, value] of Object.entries(input)) {
-        if (typeof value === "string") {
-            try {
-                value = JSON.parse(value);
-            }
-            catch { }
-        }
-        raw[key] = value;
-    }
-}
-export function wrapCloudflareHandler(handler) {
-    if (typeof handler === "function" && handler.hasOwnProperty("prototype")) {
-        return class extends handler {
-            constructor(ctx, env) {
-                fromCloudflareEnv(env);
-                super(ctx, env);
-            }
-        };
-    }
-    function wrap(fn) {
-        return function (req, env, ...rest) {
-            fromCloudflareEnv(env);
-            return fn(req, env, ...rest);
-        };
-    }
-    const result = {};
-    for (const [key, value] of Object.entries(handler)) {
-        result[key] = wrap(value);
-    }
-    return result;
-}
-export const Resource = new Proxy(raw, {
-    get(_target, prop) {
-        if (prop in raw) {
-            return raw[prop];
-        }
-        throw new Error(`"${prop}" is not linked`);
-    },
-});

package/dist/util/prettify.d.ts

@@ -1,3 +0,0 @@
-export type Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};

package/dist/util/prettify.js

@@ -1 +0,0 @@
-export {};

package/dist/vector/index.d.ts

@@ -1,193 +0,0 @@
-import { Resource } from "../resource.js";
-export interface PutEvent {
-    /**
-     * The vector to store in the database.
-     * @example
-     * ```js
-     * {
-     *   vector: [32.4, 6.55, 11.2, 10.3, 87.9],
-     * }
-     * ```
-     */
-    vector: number[];
-    /**
-     * Metadata for the event in JSON format.
-     * This metadata will be used to filter when quering and removing vectors.
-     * @example
-     * ```js
-     * {
-     *   metadata: {
-     *     type: "movie",
-     *     id: "movie-123",
-     *     name: "Spiderman",
-     *   }
-     * }
-     * ```
-     */
-    metadata: Record<string, any>;
-}
-export interface QueryEvent {
-    /**
-     * The vector used to query the database.
-     * @example
-     * ```js
-     * {
-     *   vector: [32.4, 6.55, 11.2, 10.3, 87.9],
-     * }
-     * ```
-     */
-    vector: number[];
-    /**
-     * The metadata used to filter the vectors.
-     * Only vectors that match the provided fields will be returned.
-     * @example
-     * ```js
-     * {
-     *   include: {
-     *     type: "movie",
-     *     release: "2001",
-     *   }
-     * }
-     * ```
-     * This will match the vector with metadata:
-     * ```js
-     *  {
-     *    type: "movie",
-     *    name: "Spiderman",
-     *    release: "2001",
-     *  }
-     * ```
-     *
-     * But not the vector with metadata:
-     * ```js
-     *  {
-     *    type: "book",
-     *    name: "Spiderman",
-     *    release: "2001",
-     *  }
-     * ```
-     */
-    include: Record<string, any>;
-    /**
-     * Exclude vectors with metadata that match the provided fields.
-     * @example
-     * ```js
-     * {
-     *   include: {
-     *     type: "movie",
-     *     release: "2001",
-     *   },
-     *   exclude: {
-     *     name: "Spiderman",
-     *   }
-     * }
-     * ```
-     * This will match the vector with metadata:
-     * ```js
-     *  {
-     *    type: "movie",
-     *    name: "A Beautiful Mind",
-     *    release: "2001",
-     *  }
-     * ```
-     *
-     * But not the vector with metadata:
-     * ```js
-     *  {
-     *    type: "book",
-     *    name: "Spiderman",
-     *    release: "2001",
-     *  }
-     * ```
-     */
-    exclude?: Record<string, any>;
-    /**
-     * The threshold of similarity between the prompt and the queried vectors.
-     * Only vectors with a similarity score higher than the threshold will be returned.
-     * Expected value is between 0 and 1.
-     * - 0 means the prompt and the queried vectors are completely different.
-     * - 1 means the prompt and the queried vectors 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 interface RemoveEvent {
-    /**
-     * The metadata used to filter the removal of vectors.
-     * Only vectors with metadata that match the provided fields will be removed.
-     * @example
-     * To remove vectors for movie with id "movie-123":
-     * ```js
-     * {
-     *   include: {
-     *     id: "movie-123",
-     *   }
-     * }
-     * ```
-     * To remove vectors for all movies:
-     * ```js
-     *  {
-     *   include: {
-     *    type: "movie",
-     *   }
-     *  }
-     * ```
-     */
-    include: Record<string, any>;
-}
-export interface QueryResponse {
-    /**
-     * Metadata for the event in JSON format that was provided when storing the vector.
-     */
-    metadata: Record<string, any>;
-    /**
-     * The similarity score between the prompt and the queried vector.
-     */
-    score: number;
-}
-export interface VectorClientResponse {
-    put: (event: PutEvent) => Promise<void>;
-    query: (event: QueryEvent) => Promise<QueryResponse>;
-    remove: (event: RemoveEvent) => Promise<void>;
-}
-/**
- * Create a client to interact with the Vector database.
- * @example
- * ```js
- * import { VectorClient } from "sst";
- * const client = VectorClient("MyVectorDB");
- *
- * // Store a vector into the db
- * await client.put({
- *   vector: [32.4, 6.55, 11.2, 10.3, 87.9],
- *   metadata: { type: "movie", genre: "comedy" },
- * });
- *
- * // Query vectors similar to the provided vector
- * const result = await client.query({
- *   vector: [32.4, 6.55, 11.2, 10.3, 87.9],
- *   include: { type: "movie" },
- *   exclude: { genre: "thriller" },
- * });
- * ```
- */
-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): VectorClientResponse;

package/dist/vector/index.js

@@ -1,62 +0,0 @@
-import { LambdaClient, InvokeCommand, } from "@aws-sdk/client-lambda";
-import { Resource } from "../resource.js";
-const lambda = new LambdaClient();
-/**
- * Create a client to interact with the Vector database.
- * @example
- * ```js
- * import { VectorClient } from "sst";
- * const client = VectorClient("MyVectorDB");
- *
- * // Store a vector into the db
- * await client.put({
- *   vector: [32.4, 6.55, 11.2, 10.3, 87.9],
- *   metadata: { type: "movie", genre: "comedy" },
- * });
- *
- * // Query vectors similar to the provided vector
- * const result = await client.query({
- *   vector: [32.4, 6.55, 11.2, 10.3, 87.9],
- *   include: { type: "movie" },
- *   exclude: { genre: "thriller" },
- * });
- * ```
- */
-export function VectorClient(name) {
-    return {
-        put: async (event) => {
-            const ret = await lambda.send(new InvokeCommand({
-                // @ts-expect-error
-                FunctionName: Resource[name].putFunction,
-                Payload: JSON.stringify(event),
-            }));
-            parsePayload(ret, "Failed to store into the vector db");
-        },
-        query: async (event) => {
-            const ret = await lambda.send(new InvokeCommand({
-                // @ts-expect-error
-                FunctionName: Resource[name].queryFunction,
-                Payload: JSON.stringify(event),
-            }));
-            return parsePayload(ret, "Failed to query the vector db");
-        },
-        remove: async (event) => {
-            const ret = await lambda.send(new InvokeCommand({
-                // @ts-expect-error
-                FunctionName: Resource[name].removeFunction,
-                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;
-}