@sst-community/sst 0.0.0-placeholder.0 → 4.17.3

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

@@ -0,0 +1,5 @@
+import type { Resource as BaseResource } from "./node.js";
+export declare function wrapCloudflareHandler(handler: any): any;
+export interface Resource extends BaseResource {
+}
+export declare const Resource: Resource;

package/dist/resource/cloudflare.js

@@ -0,0 +1,30 @@
+import { env } from "cloudflare:workers";
+import { createResource, loadResourceEnvironment } from "./shared.js";
+function loadCloudflareResources() {
+    loadResourceEnvironment(env);
+}
+export function wrapCloudflareHandler(handler) {
+    if (handler == null) {
+        return undefined;
+    }
+    if (typeof handler === "function" && handler.hasOwnProperty("prototype")) {
+        return class extends handler {
+            constructor(ctx, env) {
+                loadResourceEnvironment(env);
+                super(ctx, env);
+            }
+        };
+    }
+    function wrap(fn) {
+        return function (req, env, ...rest) {
+            loadResourceEnvironment(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 = createResource(loadCloudflareResources);

package/dist/resource/index.d.ts

@@ -0,0 +1 @@
+export * from "./node.js";

package/dist/resource/index.js

@@ -0,0 +1 @@
+export * from "./node.js";

package/dist/resource/node.d.ts

@@ -0,0 +1,4 @@
+import type { Resource as BaseResource } from "./shared.js";
+export interface Resource extends BaseResource {
+}
+export declare const Resource: Resource;

package/dist/resource/node.js

@@ -0,0 +1,38 @@
+import crypto from "crypto";
+import { readFileSync } from "fs";
+import { env } from "process";
+import { createResource, loadResourceData, loadResourceEnvironment, } from "./shared.js";
+const state = globalThis;
+function loadNodeResources() {
+    const environment = {
+        ...env,
+        ...globalThis.process?.env,
+    };
+    loadResourceEnvironment(environment);
+    if (environment.SST_RESOURCES_JSON) {
+        try {
+            loadResourceData(JSON.parse(environment.SST_RESOURCES_JSON));
+        }
+        catch (error) {
+            console.error("Failed to parse SST_RESOURCES_JSON:", error);
+        }
+    }
+    if (environment.SST_KEY_FILE &&
+        environment.SST_KEY &&
+        !state.SST_KEY_FILE_DATA) {
+        const key = Buffer.from(environment.SST_KEY, "base64");
+        const encryptedData = readFileSync(environment.SST_KEY_FILE);
+        const nonce = Buffer.alloc(12, 0);
+        const decipher = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+        const authTag = encryptedData.subarray(-16);
+        const actualCiphertext = encryptedData.subarray(0, -16);
+        decipher.setAuthTag(authTag);
+        let decrypted = decipher.update(actualCiphertext);
+        decrypted = Buffer.concat([decrypted, decipher.final()]);
+        loadResourceData(JSON.parse(decrypted.toString()));
+    }
+    if (state.SST_KEY_FILE_DATA) {
+        loadResourceData(state.SST_KEY_FILE_DATA);
+    }
+}
+export const Resource = createResource(loadNodeResources);

package/dist/resource/shared.d.ts

@@ -0,0 +1,9 @@
+export interface Resource {
+    App: {
+        name: string;
+        stage: string;
+    };
+}
+export declare function loadResourceEnvironment(input?: Record<string, any>): void;
+export declare function loadResourceData(input?: Record<string, any>): void;
+export declare function createResource<T extends Resource>(load: () => void): T;

package/dist/resource/shared.js

@@ -0,0 +1,62 @@
+const state = globalThis;
+const raw = (state.__SST_RESOURCE_RAW__ ??= {
+    // @ts-expect-error
+    ...globalThis.$SST_LINKS,
+});
+const environment = (state.__SST_RESOURCE_ENVIRONMENT__ ??= {});
+export function loadResourceEnvironment(input) {
+    for (let [key, value] of Object.entries(input ?? {})) {
+        if (typeof value === "string") {
+            environment[key] = value;
+            if (!key.startsWith("SST_RESOURCE_") || !value) {
+                continue;
+            }
+            raw[key.slice("SST_RESOURCE_".length)] = JSON.parse(value);
+            continue;
+        }
+        raw[key] = value;
+    }
+}
+export function loadResourceData(input) {
+    Object.assign(raw, input ?? {});
+}
+export function createResource(load) {
+    let loaded = false;
+    const loadData = () => {
+        if (loaded)
+            return;
+        load();
+        loaded = true;
+    };
+    return new Proxy(raw, {
+        get(_target, prop) {
+            loadData();
+            if (prop in raw) {
+                return raw[prop];
+            }
+            if (typeof prop !== "string") {
+                return undefined;
+            }
+            if (!environment.SST_RESOURCE_App && !raw.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 (environment.AWS_LAMBDA_FUNCTION_NAME) {
+                msg += ` to ${environment.AWS_LAMBDA_FUNCTION_NAME}`;
+            }
+            throw new Error(msg);
+        },
+        has(_target, prop) {
+            loadData();
+            return prop in raw;
+        },
+        ownKeys() {
+            loadData();
+            return Reflect.ownKeys(raw);
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            loadData();
+            return Object.getOwnPropertyDescriptor(raw, prop);
+        },
+    });
+}

package/dist/resource.d.ts

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

package/dist/resource.js

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

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,247 @@
+import { Resource } from "../resource/index.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. When omitted, performs a metadata-only
+     * query and returns `score: 0` for each result.
+     * @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.
+     * @default `{}`
+     * @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
+     * Query by vector similarity.
+     * ```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 by metadata only (no vector). Returns `score: 0` for each result.
+     * ```ts title="src/lambda.ts"
+     * const result = await client.query({
+     *   include: { type: "movie" },
+     * });
+     * ```
+     */
+    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,107 @@
+import { Resource } from "../resource/index.js";
+import { client } from "../aws/client.js";
+/**
+ * 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) => {
+            await invokeFunction(
+            // @ts-expect-error
+            Resource[name].putFunction, JSON.stringify(event), "Failed to store into the vector db");
+        },
+        query: async (event) => {
+            return await invokeFunction(
+            // @ts-expect-error
+            Resource[name].queryFunction, JSON.stringify(event), "Failed to query the vector db");
+        },
+        remove: async (event) => {
+            await invokeFunction(
+            // @ts-expect-error
+            Resource[name].removeFunction, JSON.stringify(event), "Failed to remove from the vector db");
+        },
+    };
+}
+async function invokeFunction(functionName, body, errorMessage, attempts = 0) {
+    try {
+        const c = await client();
+        const endpoint = `https://lambda.${process.env.AWS_REGION}.amazonaws.com/2015-03-31`;
+        const response = await c.fetch(`${endpoint}/functions/${functionName}/invocations`, {
+            method: "POST",
+            headers: { Accept: "application/json" },
+            body,
+        });
+        // success
+        if (response.status === 200 || response.status === 201) {
+            if (response.headers.get("content-length") === "0")
+                return undefined;
+            const text = await response.text();
+            try {
+                return JSON.parse(text);
+            }
+            catch (e) {
+                throw new Error(`Failed to parse JSON response: ${text}`);
+            }
+        }
+        // error
+        const error = new Error();
+        const text = await response.text();
+        try {
+            const json = JSON.parse(text);
+            error.name = json.Error?.Code;
+            error.message = json.Error?.Message ?? json.message ?? text;
+        }
+        catch (e) {
+            error.message = text;
+        }
+        error.name = error.name ?? response.headers.get("x-amzn-ErrorType");
+        // @ts-expect-error
+        error.requestID = response.headers.get("x-amzn-RequestId");
+        // @ts-expect-error
+        error.statusCode = response.status;
+        throw error;
+    }
+    catch (e) {
+        let isRetryable = false;
+        // AWS throttling errors => retry
+        if ([
+            "ThrottlingException",
+            "Throttling",
+            "TooManyRequestsException",
+            "OperationAbortedException",
+            "TimeoutError",
+            "NetworkingError",
+        ].includes(e.name)) {
+            isRetryable = true;
+        }
+        if (!isRetryable)
+            throw e;
+        // retry
+        await new Promise((resolve) => setTimeout(resolve, 1.5 ** attempts * 100 * Math.random()));
+        return await invokeFunction(functionName, body, errorMessage, attempts + 1);
+    }
+}

package/package.json

@@ -1 +1,73 @@
-{"name":"@sst-community/sst","version":"0.0.0-placeholder.0","license":"MIT","repository":{"type":"git","url":"git+https://github.com/sst-community/sst.git"}}
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@sst-community/sst",
+  "type": "module",
+  "sideEffects": false,
+  "version": "4.17.3",
+  "main": "./dist/index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sst-community/sst.git"
+  },
+  "license": "MIT",
+  "exports": {
+    ".": "./dist/index.js",
+    "./resource": {
+      "types": "./dist/resource/index.d.ts",
+      "workerd": "./dist/resource/cloudflare.js",
+      "worker": "./dist/resource/cloudflare.js",
+      "default": "./dist/resource/node.js"
+    },
+    "./resource/cloudflare": {
+      "types": "./dist/resource/cloudflare.d.ts",
+      "default": "./dist/resource/cloudflare.js"
+    },
+    "./auth": "./dist/auth/index.js",
+    "./auth/adapter": "./dist/auth/adapter/index.js",
+    "./event": "./dist/event/index.js",
+    "./realtime": "./dist/realtime/index.js",
+    "./*": {
+      "import": "./dist/*.js",
+      "types": "./dist/*.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w",
+    "release": "./scripts/release.ts"
+  },
+  "devDependencies": {
+    "@aws/durable-execution-sdk-js-testing": "^1.1.1",
+    "@tsconfig/node20": "20.1.4",
+    "@types/aws-lambda": "^8.10.155",
+    "@types/node": "22.10.0",
+    "bun-types": "1.3.0",
+    "hono": "4.3.9",
+    "typescript": "5.7.2",
+    "valibot": "^1.0.0-rc.3",
+    "zod": "^3.24.2"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "bin": {
+    "sst": "./bin/sst.mjs"
+  },
+  "optionalDependencies": {
+    "@sst-community/sst-linux-x64": "4.17.3",
+    "@sst-community/sst-linux-x86": "4.17.3",
+    "@sst-community/sst-linux-arm64": "4.17.3",
+    "@sst-community/sst-darwin-x64": "4.17.3",
+    "@sst-community/sst-darwin-arm64": "4.17.3",
+    "@sst-community/sst-win32-x64": "4.17.3",
+    "@sst-community/sst-win32-x86": "4.17.3",
+    "@sst-community/sst-win32-arm64": "4.17.3"
+  },
+  "dependencies": {
+    "@aws/durable-execution-sdk-js": "1.0.2",
+    "aws4fetch": "1.0.18",
+    "jose": "5.2.3",
+    "openid-client": "5.6.4"
+  }
+}