sst 3.0.1-8 → 3.0.1

package/dist/event/index.d.ts

@@ -0,0 +1,72 @@
+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<Metadata extends ((type: string, properties: any) => any) | Parameters<Validator>[0], Validator extends (schema: any) => (input: any) => any>(input: {
+        validator: Validator;
+        metadata?: Metadata;
+    }): {
+        <Type extends string, Schema extends Parameters<Validator>[0]>(type: Type, schema: Schema): {
+            create: Metadata extends (type: string, properties: any) => any ? (properties: inferParser<Schema>["in"]) => Promise<{
+                type: Type;
+                properties: inferParser<Schema>["out"];
+                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: Metadata extends (type: string, properties: any) => any ? ReturnType<Metadata> : inferParser<Metadata>["out"];
+            }>;
+            type: Type;
+            $input: inferParser<Schema>["in"];
+            $output: inferParser<Schema>["out"];
+            $payload: {
+                type: Type;
+                properties: inferParser<Schema>["out"];
+                metadata: Metadata extends (type: string, properties: any) => any ? ReturnType<Metadata> : inferParser<Metadata>["out"];
+            };
+            $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;
+        }>["$payload"]; }[Events["type"]];
+    };
+    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

@@ -0,0 +1,35 @@
+export var event;
+(function (event) {
+    function builder(input) {
+        const validator = input.validator;
+        const fn = function event(type, schema) {
+            const validate = validator(schema);
+            async function create(properties, metadata) {
+                metadata = input.metadata
+                    ? typeof input.metadata === "function"
+                        ? input.metadata(type, properties)
+                        : input.metadata(metadata)
+                    : {};
+                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;
+})(event || (event = {}));

package/dist/event/validator.d.ts

@@ -0,0 +1,4 @@
+import { ZodSchema, z } from "zod";
+export declare function ZodValidator<Schema extends ZodSchema>(schema: Schema): (input: z.input<Schema>) => z.output<Schema>;
+import { BaseSchema, Input } from "valibot";
+export declare function ValibotValidator<T extends BaseSchema>(schema: T): (value: Input<T>) => import("valibot").Output<T>;

package/dist/event/validator.js

@@ -0,0 +1,11 @@
+export function ZodValidator(schema) {
+    return (input) => {
+        return schema.parse(input);
+    };
+}
+import { parse } from "valibot";
+export function ValibotValidator(schema) {
+    return (value) => {
+        return parse(schema, value);
+    };
+}

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/realtime/index.d.ts

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,24 @@
+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,7 +1,9 @@
 export interface Resource {
-    [key: string]: any;
-}
-declare global {
-    export const $SST_LINKS: 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,8 +1,57 @@
-export const Resource = new Proxy($SST_LINKS, {
-    get(target, prop) {
-        if (!(prop in target)) {
-            throw new Error(`"${prop}" is not linked`);
+import { env } from "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 { }
         }
-        return target[prop];
+        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];
+        }
+        if (!env.SST_RESOURCE_App) {
+            throw new Error("It does not look like SST links are active. If this is in local development and you are not starting this process through the multiplexer, wrap your command with `sst dev -- <command>`");
+        }
+        let msg = `"${prop}" is not linked in your sst.config.ts`;
+        if (env.AWS_LAMBDA_FUNCTION_NAME) {
+            msg += ` to ${env.AWS_LAMBDA_FUNCTION_NAME}`;
+        }
+        throw new Error(msg);
     },
 });

package/dist/util/prettify.d.ts

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

package/dist/util/prettify.js

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

package/dist/vector/index.d.ts

@@ -0,0 +1,238 @@
+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 as JSON.
+     * This will be used to filter when querying 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
+     * Given this filter.
+     * ```js
+     * {
+     *   include: {
+     *     type: "movie",
+     *     release: "2001"
+     *   }
+     * }
+     * ```
+     * It will match a vector with the metadata:
+     * ```js
+     * {
+     *   type: "movie",
+     *   name: "Spiderman",
+     *   release: "2001"
+     * }
+     * ```
+     *
+     * But not a vector with this metadata:
+     * ```js
+     *  {
+     *    type: "book",
+     *    name: "Spiderman",
+     *    release: "2001"
+     *  }
+     * ```
+     */
+    include: Record<string, any>;
+    /**
+     * Exclude vectors with metadata that match the provided fields.
+     * @example
+     * Given this filter.
+     * ```js
+     * {
+     *   include: {
+     *     type: "movie",
+     *     release: "2001"
+     *   },
+     *   exclude: {
+     *     name: "Spiderman"
+     *   }
+     * }
+     * ```
+     * This will match a vector with metadata:
+     * ```js
+     *  {
+     *    type: "movie",
+     *    name: "A Beautiful Mind",
+     *    release: "2001"
+     *  }
+     * ```
+     *
+     * But not a vector with the 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.
+     *
+     * This will return values 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 {
+    /**
+     * List of results matching the query.
+     */
+    results: {
+        /**
+         * Metadata for the event 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 {
+    /**
+     * Store a vector into the database.
+     * @example
+     * ```ts title="src/lambda.ts"
+     * await client.put({
+     *   vector: [32.4, 6.55, 11.2, 10.3, 87.9],
+     *   metadata: { type: "movie", genre: "comedy" },
+     * });
+     * ```
+     */
+    put: (event: PutEvent) => Promise<void>;
+    /**
+     * Query vectors that are similar to the given vector
+     * @example
+     * ```ts title="src/lambda.ts"
+     * const result = await client.query({
+     *   vector: [32.4, 6.55, 11.2, 10.3, 87.9],
+     *   include: { type: "movie" },
+     *   exclude: { genre: "thriller" },
+     * });
+     * ```
+     */
+    query: (event: QueryEvent) => Promise<QueryResponse>;
+    /**
+     * Remove vectors from the database.
+     * @example
+     * ```ts title="src/lambda.ts"
+     * await client.remove({
+     *   include: { type: "movie" },
+     * });
+     * ```
+     */
+    remove: (event: RemoveEvent) => Promise<void>;
+}
+/**
+ * Create a client to interact with the Vector database.
+ * @example
+ * ```ts title="src/lambda.ts"
+ * import { VectorClient } from "sst";
+ * const client = VectorClient("MyVectorDB");
+ * ```
+ *
+ * Store a vector into the db
+ *
+ * ```ts title="src/lambda.ts"
+ * await client.put({
+ *   vector: [32.4, 6.55, 11.2, 10.3, 87.9],
+ *   metadata: { type: "movie", genre: "comedy" },
+ * });
+ * ```
+ *
+ * Query vectors that are similar to the given vector
+ *
+ * ```ts title="src/lambda.ts"
+ * 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

@@ -0,0 +1,68 @@
+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
+ * ```ts title="src/lambda.ts"
+ * import { VectorClient } from "sst";
+ * const client = VectorClient("MyVectorDB");
+ * ```
+ *
+ * Store a vector into the db
+ *
+ * ```ts title="src/lambda.ts"
+ * await client.put({
+ *   vector: [32.4, 6.55, 11.2, 10.3, 87.9],
+ *   metadata: { type: "movie", genre: "comedy" },
+ * });
+ * ```
+ *
+ * Query vectors that are similar to the given vector
+ *
+ * ```ts title="src/lambda.ts"
+ * 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;
+}

package/package.json

@@ -2,26 +2,61 @@
   "$schema": "https://json.schemastore.org/package.json",
   "name": "sst",
   "type": "module",
-  "version": "3.0.1-8",
+  "sideEffects": false,
+  "version": "3.0.1",
   "main": "./dist/index.js",
   "exports": {
     ".": "./dist/index.js",
+    "./auth": "./dist/auth/index.js",
+    "./auth/adapter": "./dist/auth/adapter/index.js",
+    "./event": "./dist/event/index.js",
+    "./realtime": "./dist/realtime/index.js",
     "./*": "./dist/*.js"
   },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w",
+    "release": "./scripts/release.ts"
+  },
   "devDependencies": {
-    "@tsconfig/node18": "^18.2.2",
-    "@types/node": "^20.11.0",
-    "typescript": "^5.3.3"
+    "@tsconfig/node20": "20.1.4",
+    "@types/bun": "^1.1.6",
+    "@types/node": "20.11.0",
+    "hono": "4.3.9",
+    "typescript": "5.3.3",
+    "valibot": "0.30.0",
+    "zod": "3.23.8"
   },
   "files": [
-    "dist"
+    "dist",
+    "bin"
   ],
-  "dependencies": {
-    "@aws-sdk/client-lambda": "3.478.0"
+  "bin": {
+    "sst": "./bin/sst.mjs"
   },
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsc -w",
-    "release": "pnpm build && pnpm version prerelease && pnpm publish --no-git-checks --tag=ion --access=public"
+  "peerDependencies": {
+    "hono": "4.x",
+    "valibot": "0.30.x"
+  },
+  "peerDependenciesMeta": {
+    "hono": {
+      "optional": true
+    },
+    "valibot": {
+      "optional": true
+    }
+  },
+  "optionalDependencies": {
+    "sst-linux-x64": "3.0.1",
+    "sst-linux-x86": "3.0.1",
+    "sst-linux-arm64": "3.0.1",
+    "sst-darwin-x64": "3.0.1",
+    "sst-darwin-arm64": "3.0.1"
+  },
+  "dependencies": {
+    "@aws-sdk/client-lambda": "3.478.0",
+    "aws4fetch": "^1.0.18",
+    "jose": "5.2.3",
+    "openid-client": "5.6.4"
   }
 }